turbo-tasks: replace async resolve fns with custom Future types (ResolveRawVcFuture, ResolveVcFuture, ToResolvedVcFuture) (#91554)

### What?

Replace the `async fn resolve()`, `async fn
resolve_strongly_consistent()`, and `async fn to_resolved()` methods on
`RawVc`, `Vc<T>`, and `OperationVc<T>` with hand-written custom `Future`
implementations, following the existing `ReadRawVcFuture` pattern.

New types:
- **`ResolveRawVcFuture`** (`raw_vc.rs`) — core implementation, replaces
`async fn resolve_inner()`
- **`ResolveVcFuture<T>`** (`vc/mod.rs`) — typed wrapper over
`ResolveRawVcFuture`, returned by `Vc::resolve()`
- **`ResolveOperationVcFuture<T>`** (`vc/operation.rs`) — typed wrapper,
returned by `OperationVc::resolve()`
- **`ToResolvedVcFuture<T>`** (`vc/mod.rs`) — typed wrapper, returned by
`Vc::to_resolved()`

All new future types expose a `.strongly_consistent()` builder method,
enabling `resolve_strongly_consistent()` to be replaced by
`.resolve().strongly_consistent()` at call sites.

`ReadRawVcFuture` is also updated to delegate its phase-1 resolve loop
to `ResolveRawVcFuture` instead of duplicating the logic.
`std::task::ready!` is used throughout to simplify poll implementations.

Also adds `#[inline(never)]` to `ReadRawVcFuture::poll` and
`ResolveRawVcFuture::poll` to avoid inlining large poll implementations
into every await site.

### Why?

Performance, binary size, and improved API ergonomics:

- The hand-written `Future` pattern (already used by `ReadRawVcFuture`)
gives the compiler more predictable, smaller code than the state
machines generated for `async fn`. The `#[inline(never)]` attributes on
`poll` prevent large poll bodies from being duplicated at every await
site, which the async desugaring otherwise allows.
- The new builder API (`.resolve().strongly_consistent()`) is more
composable and removes the need for separate `_strongly_consistent`
method variants, reducing the number of methods on
`RawVc`/`Vc`/`OperationVc`.
- Having `ReadRawVcFuture` delegate to `ResolveRawVcFuture` removes the
duplicated resolve loop and ensures both paths stay in sync.

### How?

- `ResolveRawVcFuture` stores `current: RawVc`, `read_output_options:
ReadOutputOptions`, `strongly_consistent: bool`, and `listener:
Option<EventListener>`. Its `poll` replicates the loop from the old
`resolve_inner` using `try_read_task_output` / `try_read_local_output`.
- On `Err(listener)` from a `try_*` call, the listener is stored in
`self.listener` and `Poll::Pending` is returned. At the top of the loop,
`ready!(poll_listener(...))` re-polls it and short-circuits if still
pending.
- Consistency is downgraded to `Eventual` after the first `TaskOutput`
hop, matching the previous behavior.
- `strongly_consistent: true` keeps the
`SUPPRESS_EVENTUAL_CONSISTENCY_TOP_LEVEL_TASK_CHECK` suppression across
all polls (same logic as `ReadRawVcFuture`).
- `ReadRawVcFuture` now holds a `ResolveRawVcFuture` for phase 1 and
drives it via `Pin::new(&mut self.resolve).poll(cx)` before proceeding
to the cell read in phase 2. This eliminates the duplicated loop that
previously existed in both types.
- Typed wrappers (`ResolveVcFuture<T>`, `ResolveOperationVcFuture<T>`,
`ToResolvedVcFuture<T>`) delegate `poll` to the inner
`ResolveRawVcFuture` and map the output to the appropriate typed result.
- `OperationVc::resolve_strongly_consistent()` is removed; 16 call sites
updated to `.resolve().strongly_consistent()`.
- All new types implement `Unpin` and are exported from `lib.rs`.
- `std::task::ready!` is used in all `poll` implementations to reduce
boilerplate.

No behavioral changes — this is a pure implementation refactor.

### Binary size impact

A release build (`pnpm swc-build-native --release`) was measured before
and after the branch changes on the same merge-base commit (`a41bef94`):

| | Size |
|---|---|
| Base (`a41bef94`, before branch) | 199,690,656 bytes (~190.4 MB) |
| Branch (`6f7846f9`, after changes) | 199,252,384 bytes (~190.0 MB) |
| **Difference** | **−438,272 bytes (−428 KB, −0.22%)** |

The branch produces a slightly smaller binary. The reduction comes
primarily from the `#[inline(never)]` attributes preventing large `poll`
bodies from being duplicated at every await site.

---------

Co-authored-by: Tobias Koppers <[email protected]>
Co-authored-by: Claude <[email protected]>

Author: sokra

crates/next-api/src/module_graph.rs

@@ -76,7 +76,7 @@ impl NextDynamicGraphs {
         // `get_global_information_for_endpoint_inner` calls `take_collectibles()` when needed
         let result_op = Self::new_operation(graphs, is_single_page);
         let result_vc = if !is_single_page {
-            let result_vc = result_op.resolve_strongly_consistent().await?;
+            let result_vc = result_op.resolve().strongly_consistent().await?;
             result_op.drop_collectibles::<Box<dyn Issue>>();
             *result_vc
         } else {
@@ -274,7 +274,7 @@ impl ServerActionsGraphs {
         // `get_global_information_for_endpoint_inner` calls `take_collectibles()` when needed
         let result_op = Self::new_operation(graphs, is_single_page);
         let result_vc = if !is_single_page {
-            let result_vc = result_op.resolve_strongly_consistent().await?;
+            let result_vc = result_op.resolve().strongly_consistent().await?;
             result_op.drop_collectibles::<Box<dyn Issue>>();
             *result_vc
         } else {
@@ -452,7 +452,7 @@ impl ClientReferencesGraphs {
         // `get_global_information_for_endpoint_inner` calls `take_collectibles()` when needed
         let result_op = Self::new_operation(graphs, is_single_page);
         let result_vc = if !is_single_page {
-            let result_vc = result_op.resolve_strongly_consistent().await?;
+            let result_vc = result_op.resolve().strongly_consistent().await?;
             result_op.drop_collectibles::<Box<dyn Issue>>();
             *result_vc
         } else {

crates/next-api/src/operation.rs

@@ -37,7 +37,7 @@ pub struct EntrypointsOperation {
 async fn entrypoints_without_collectibles_operation(
     entrypoints: OperationVc<Entrypoints>,
 ) -> Result<Vc<Entrypoints>> {
-    let _ = entrypoints.resolve_strongly_consistent().await?;
+    let _ = entrypoints.resolve().strongly_consistent().await?;
     entrypoints.drop_collectibles::<Box<dyn Diagnostic>>();
     entrypoints.drop_issues();
     let _ = get_effects(entrypoints).await?;

crates/next-api/src/project.rs

@@ -615,7 +615,8 @@ impl ProjectContainer {
                 container.connect().project()
             }
             let project = project_from_container_operation(this_op)
-                .resolve_strongly_consistent()
+                .resolve()
+                .strongly_consistent()
                 .await?;
             let project_fs = project_fs_operation(project)
                 .read_strongly_consistent()
@@ -738,7 +739,8 @@ impl ProjectContainer {
             let watch = new_options.watch;
 
             let project = project_operation(self)
-                .resolve_strongly_consistent()
+                .resolve()
+                .strongly_consistent()
                 .await?;
             let prev_project_fs = project_fs_operation(project)
                 .read_strongly_consistent()
@@ -756,7 +758,8 @@ impl ProjectContainer {
             }
             this.options_state.set(Some(new_options));
             let project = project_operation(self)
-                .resolve_strongly_consistent()
+                .resolve()
+                .strongly_consistent()
                 .await?;
             let project_fs = project_fs_operation(project)
                 .read_strongly_consistent()
@@ -1512,7 +1515,7 @@ impl Project {
         } else {
             // In development mode, we need to to take and drop the issues, otherwise every
             // route will report all issues.
-            let vc = module_graphs_op.resolve_strongly_consistent().await?;
+            let vc = module_graphs_op.resolve().strongly_consistent().await?;
             module_graphs_op.drop_issues();
             *vc
         };

crates/next-build-test/src/lib.rs

@@ -41,7 +41,7 @@ pub async fn main_inner(
         .run(async {
             let container_op = ProjectContainer::new_operation(rcstr!("next.js"), options.dev);
             ProjectContainer::initialize(container_op, options).await?;
-            container_op.resolve_strongly_consistent().await
+            container_op.resolve().strongly_consistent().await
         })
         .await?;
 
@@ -248,7 +248,7 @@ async fn endpoint_write_to_disk_with_effects(
     endpoint: ResolvedVc<Box<dyn Endpoint>>,
 ) -> Result<Vc<EndpointOutputPaths>> {
     let op = endpoint_write_to_disk_operation(endpoint);
-    let result = op.resolve_strongly_consistent().await?;
+    let result = op.resolve().strongly_consistent().await?;
     get_effects(op).await?.apply().await?;
     Ok(*result)
 }

crates/next-napi-bindings/src/next_api/project.rs

@@ -588,7 +588,7 @@ pub fn project_new(
                 .run(async move {
                     let container_op = ProjectContainer::new_operation(rcstr!("next.js"), is_dev);
                     ProjectContainer::initialize(container_op, options).await?;
-                    container_op.resolve_strongly_consistent().await
+                    container_op.resolve().strongly_consistent().await
                 })
                 .or_else(|e| turbopack_ctx.throw_turbopack_internal_result(&e.into()))
                 .await?;

turbopack/crates/turbo-tasks-backend/tests/emptied_cells.rs

@@ -12,7 +12,7 @@ static REGISTRATION: Registration = register!();
 async fn test_emptied_cells() {
     run(&REGISTRATION, || async {
         let input_op = get_state_operation();
-        let input_vc = input_op.resolve_strongly_consistent().await?;
+        let input_vc = input_op.resolve().strongly_consistent().await?;
         let input = input_op.read_strongly_consistent().await?;
         input.state.set(0);
 

turbopack/crates/turbo-tasks-backend/tests/emptied_cells_session_dependent.rs

@@ -12,7 +12,7 @@ static REGISTRATION: Registration = register!();
 async fn test_emptied_cells_session_dependent() {
     run(&REGISTRATION, || async {
         let input_op = get_state_operation();
-        let input_vc = input_op.resolve_strongly_consistent().await?;
+        let input_vc = input_op.resolve().strongly_consistent().await?;
         let input = input_op.read_strongly_consistent().await?;
         input.state.set(0);
 

turbopack/crates/turbo-tasks-backend/tests/invalidation.rs

@@ -21,7 +21,7 @@ fn create_state_operation() -> Vc<Step> {
 async fn test_invalidation_map() {
     run(&REGISTRATION, || async {
         let state_op = create_state_operation();
-        let state_vc = state_op.resolve_strongly_consistent().await?;
+        let state_vc = state_op.resolve().strongly_consistent().await?;
         let state = state_op.read_strongly_consistent().await?;
         state.set(1);
 
@@ -101,7 +101,7 @@ async fn get_value(map: OperationVc<Map>, key: String) -> Result<Vc<GetValueResu
 async fn test_invalidation_set() {
     run(&REGISTRATION, || async {
         let state_op = create_state_operation();
-        let state_vc = state_op.resolve_strongly_consistent().await?;
+        let state_vc = state_op.resolve().strongly_consistent().await?;
         let state = state_op.read_strongly_consistent().await?;
         state.set(1);
 

turbopack/crates/turbo-tasks-backend/tests/random_change.rs

@@ -13,7 +13,7 @@ static REGISTRATION: Registration = register!();
 async fn test_random_change() {
     run_once(&REGISTRATION, || async {
         let state_op = make_state_operation();
-        let state_vc = state_op.resolve_strongly_consistent().await?;
+        let state_vc = state_op.resolve().strongly_consistent().await?;
         let state = state_op.read_strongly_consistent().await?;
 
         let mut rng = StdRng::from_seed(Default::default());

turbopack/crates/turbo-tasks-backend/tests/top_level_task_consistency.rs

@@ -39,7 +39,8 @@ async fn test_eventual_read_in_top_level_task_fails() {
 async fn test_cell_read_in_top_level_task_succeeds() {
     run_once(&REGISTRATION, || async {
         let cell = returns_value_operation()
-            .resolve_strongly_consistent()
+            .resolve()
+            .strongly_consistent()
             .await?;
         let value = cell.await?;
         assert_eq!(value.value, 42);