codemod(turbopack): Rewrite Vc fields in structs as ResolvedVc (part 4) (#71804)

Generated using a version of https://github.com/vercel/turbopack-resolved-vc-codemod . This uses Anthropic Claude Sonnet 3.5 for more complicated errors we don't have hardcoded logic for.

- Part 1: #70927
- Part 2: #71172
- Part 3: #71665

Closes PACK-3336

Author: bgw

crates/next-core/src/next_client_reference/ecmascript_client_reference/ecmascript_client_reference_transition.rs

@@ -61,7 +61,7 @@ impl Transition for NextEcmascriptClientReferenceTransition {
         let this = self.await?;
 
         let ident = match part {
-            Some(part) => source.ident().with_part(part),
+            Some(part) => source.ident().with_part(*part),
             None => source.ident(),
         };
         let ident_ref = ident.await?;

turbopack/crates/node-file-trace/src/lib.rs

@@ -23,8 +23,8 @@ use serde::Deserialize;
 use serde::Serialize;
 use tokio::sync::mpsc::channel;
 use turbo_tasks::{
-    backend::Backend, util::FormatDuration, RcStr, ReadConsistency, TaskId, TransientInstance,
-    TransientValue, TurboTasks, UpdateInfo, Value, Vc,
+    backend::Backend, util::FormatDuration, RcStr, ReadConsistency, ResolvedVc, TaskId,
+    TransientInstance, TransientValue, TurboTasks, UpdateInfo, Value, Vc,
 };
 use turbo_tasks_fs::{
     glob::Glob, DirectoryEntry, DiskFileSystem, FileSystem, FileSystemPath, ReadGlobResult,
@@ -565,11 +565,11 @@ async fn main_operation(
 
 #[turbo_tasks::function]
 async fn create_module_asset(
-    root: Vc<FileSystemPath>,
+    root: ResolvedVc<FileSystemPath>,
     process_cwd: Option<RcStr>,
     module_options: TransientInstance<ModuleOptionsContext>,
     resolve_options: TransientInstance<ResolveOptionsContext>,
-) -> Vc<ModuleAssetContext> {
+) -> Result<Vc<ModuleAssetContext>> {
     let env = Environment::new(Value::new(ExecutionEnvironment::NodeJsLambda(
         NodeJsEnvironment {
             cwd: Vc::cell(process_cwd),
@@ -581,13 +581,17 @@ async fn create_module_asset(
     let glob_mappings = vec![
         (
             root,
-            Glob::new("**/*/next/dist/server/next.js".into()),
-            ImportMapping::Ignore.into(),
+            Glob::new("**/*/next/dist/server/next.js".into())
+                .to_resolved()
+                .await?,
+            ImportMapping::Ignore.resolved_cell(),
         ),
         (
             root,
-            Glob::new("**/*/next/dist/bin/next".into()),
-            ImportMapping::Ignore.into(),
+            Glob::new("**/*/next/dist/bin/next".into())
+                .to_resolved()
+                .await?,
+            ImportMapping::Ignore.resolved_cell(),
         ),
     ];
     let mut resolve_options = ResolveOptionsContext::clone(&*resolve_options);
@@ -603,13 +607,13 @@ async fn create_module_asset(
         );
     }
 
-    ModuleAssetContext::new(
+    Ok(ModuleAssetContext::new(
         Default::default(),
         compile_time_info,
         ModuleOptionsContext::clone(&*module_options).cell(),
         resolve_options.cell(),
         Vc::cell("node_file_trace".into()),
-    )
+    ))
 }
 
 fn register() {

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -386,7 +386,7 @@ impl ChunkingContext for BrowserChunkingContext {
 
             let mut assets: Vec<Vc<Box<dyn OutputAsset>>> = chunks
                 .iter()
-                .map(|chunk| self.generate_chunk(*chunk))
+                .map(|chunk| self.generate_chunk(**chunk))
                 .collect();
 
             if this.enable_hot_module_replacement {
@@ -455,7 +455,7 @@ impl ChunkingContext for BrowserChunkingContext {
 
             let mut assets: Vec<Vc<Box<dyn OutputAsset>>> = chunks
                 .iter()
-                .map(|chunk| self.generate_chunk(*chunk))
+                .map(|chunk| self.generate_chunk(**chunk))
                 .collect();
 
             let other_assets = Vc::cell(assets.clone());

turbopack/crates/turbopack-browser/src/ecmascript/merged/update.rs

@@ -215,7 +215,7 @@ pub(super) async fn update_ecmascript_merged_chunk(
                         if merged_module_map.get(&module_id) != Some(module_hash) {
                             let entry = EcmascriptModuleEntry::from_code(
                                 &module_id,
-                                module_code,
+                                *module_code,
                                 chunk_path,
                             )
                             .await?;
@@ -227,7 +227,7 @@ pub(super) async fn update_ecmascript_merged_chunk(
 
                     for (module_id, module_code) in chunk_partial.modified {
                         let entry =
-                            EcmascriptModuleEntry::from_code(&module_id, module_code, chunk_path)
+                            EcmascriptModuleEntry::from_code(&module_id, *module_code, chunk_path)
                                 .await?;
                         merged_update.entries.insert(module_id, entry);
                     }

turbopack/crates/turbopack-browser/src/ecmascript/update.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use turbo_tasks::{FxIndexMap, ReadRef, Vc};
+use turbo_tasks::{FxIndexMap, ReadRef, ResolvedVc, Vc};
 use turbopack_core::{chunk::ModuleId, code_builder::Code};
 
 use super::{content::EcmascriptDevChunkContent, version::EcmascriptDevChunkVersion};
@@ -11,9 +11,9 @@ pub(super) enum EcmascriptChunkUpdate {
 }
 
 pub(super) struct EcmascriptChunkPartialUpdate {
-    pub added: FxIndexMap<ReadRef<ModuleId>, (u64, Vc<Code>)>,
+    pub added: FxIndexMap<ReadRef<ModuleId>, (u64, ResolvedVc<Code>)>,
     pub deleted: FxIndexMap<ReadRef<ModuleId>, u64>,
-    pub modified: FxIndexMap<ReadRef<ModuleId>, Vc<Code>>,
+    pub modified: FxIndexMap<ReadRef<ModuleId>, ResolvedVc<Code>>,
 }
 
 pub(super) async fn update_ecmascript_chunk(
@@ -40,7 +40,8 @@ pub(super) async fn update_ecmascript_chunk(
     for (id, from_hash) in &from.entries_hashes {
         if let Some(entry) = entries.get(id) {
             if *entry.hash.await? != *from_hash {
-                modified.insert(id.clone(), entry.code);
+                let resolved_code = entry.code.to_resolved().await?;
+                modified.insert(id.clone(), resolved_code);
             }
         } else {
             deleted.insert(id.clone(), *from_hash);
@@ -50,7 +51,10 @@ pub(super) async fn update_ecmascript_chunk(
     // Remaining entries are added
     for (id, entry) in entries.iter() {
         if !from.entries_hashes.contains_key(id) {
-            added.insert(id.clone(), (*entry.hash.await?, entry.code));
+            added.insert(
+                id.clone(),
+                (*entry.hash.await?, entry.code.to_resolved().await?),
+            );
         }
     }
 

turbopack/crates/turbopack-cli-utils/src/runtime_entry.rs

@@ -62,7 +62,7 @@ impl RuntimeEntry {
 }
 
 #[turbo_tasks::value(transparent)]
-pub struct RuntimeEntries(Vec<Vc<RuntimeEntry>>);
+pub struct RuntimeEntries(Vec<ResolvedVc<RuntimeEntry>>);
 
 #[turbo_tasks::value_impl]
 impl RuntimeEntries {

turbopack/crates/turbopack-cli/src/build/mod.rs

@@ -118,7 +118,7 @@ impl TurbopackBuildBuilder {
                     self.entry_requests
                         .iter()
                         .cloned()
-                        .map(EntryRequest::cell)
+                        .map(EntryRequest::resolved_cell)
                         .collect(),
                 )
                 .cell(),

turbopack/crates/turbopack-cli/src/dev/web_entry_source.rs

@@ -72,7 +72,7 @@ pub async fn get_client_runtime_entries(
                 request.to_resolved().await?,
                 project_path.join("_".into()).to_resolved().await?,
             )
-            .cell(),
+            .resolved_cell(),
         )
     };
 
@@ -82,7 +82,7 @@ pub async fn get_client_runtime_entries(
                 .to_resolved()
                 .await?,
         ))
-        .cell(),
+        .resolved_cell(),
     );
 
     Ok(Vc::cell(runtime_entries))

turbopack/crates/turbopack-cli/src/util.rs

@@ -2,11 +2,11 @@ use std::{env::current_dir, path::PathBuf};
 
 use anyhow::{Context, Result};
 use dunce::canonicalize;
-use turbo_tasks::{RcStr, Vc};
+use turbo_tasks::{RcStr, ResolvedVc, Vc};
 use turbo_tasks_fs::{DiskFileSystem, FileSystem};
 
 #[turbo_tasks::value(transparent)]
-pub struct EntryRequests(pub Vec<Vc<EntryRequest>>);
+pub struct EntryRequests(pub Vec<ResolvedVc<EntryRequest>>);
 
 #[turbo_tasks::value(shared)]
 #[derive(Clone)]

turbopack/crates/turbopack-core/src/chunk/available_chunk_items.rs

@@ -17,7 +17,9 @@ pub struct AvailableChunkItemInfo {
 pub struct OptionAvailableChunkItemInfo(Option<AvailableChunkItemInfo>);
 
 #[turbo_tasks::value(transparent)]
-pub struct AvailableChunkItemInfoMap(FxIndexMap<Vc<Box<dyn ChunkItem>>, AvailableChunkItemInfo>);
+pub struct AvailableChunkItemInfoMap(
+    FxIndexMap<ResolvedVc<Box<dyn ChunkItem>>, AvailableChunkItemInfo>,
+);
 
 /// Allows to gather information about which assets are already available.
 /// Adding more roots will form a linked list like structure to allow caching
@@ -41,23 +43,23 @@ impl AvailableChunkItems {
 
     #[turbo_tasks::function]
     pub async fn with_chunk_items(
-        self: Vc<Self>,
+        self: ResolvedVc<Self>,
         chunk_items: Vc<AvailableChunkItemInfoMap>,
     ) -> Result<Vc<Self>> {
         let chunk_items = chunk_items
             .await?
             .into_iter()
             .map(|(&chunk_item, &info)| async move {
                 Ok(self
-                    .get(chunk_item)
+                    .get(*chunk_item)
                     .await?
                     .is_none()
                     .then_some((chunk_item, info)))
             })
             .try_flat_join()
             .await?;
         Ok(AvailableChunkItems {
-            parent: Some(self.to_resolved().await?),
+            parent: Some(self),
             chunk_items: Vc::cell(chunk_items.into_iter().collect()),
         }
         .cell())
@@ -87,13 +89,13 @@ impl AvailableChunkItems {
     #[turbo_tasks::function]
     pub async fn get(
         &self,
-        chunk_item: Vc<Box<dyn ChunkItem>>,
+        chunk_item: ResolvedVc<Box<dyn ChunkItem>>,
     ) -> Result<Vc<OptionAvailableChunkItemInfo>> {
         if let Some(&info) = self.chunk_items.await?.get(&chunk_item) {
             return Ok(Vc::cell(Some(info)));
         };
         if let Some(parent) = self.parent {
-            return Ok(parent.get(chunk_item));
+            return Ok(parent.get(*chunk_item));
         }
         Ok(Vc::cell(None))
     }