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

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

@@ -569,7 +569,7 @@ async fn create_module_asset(
     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),
@@ -580,14 +580,18 @@ async fn create_module_asset(
     let compile_time_info = CompileTimeInfo::builder(env).cell();
     let glob_mappings = vec![
         (
-            root,
-            Glob::new("**/*/next/dist/server/next.js".into()),
-            ImportMapping::Ignore.into(),
+            root.to_resolved().await?,
+            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(),
+            root.to_resolved().await?,
+            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) // Changed from cell() to resolved_cell()
                         .collect(),
                 )
                 .cell(),

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

@@ -72,7 +72,8 @@ pub async fn get_client_runtime_entries(
                 request.to_resolved().await?,
                 project_path.join("_".into()).to_resolved().await?,
             )
-            .cell(),
+            .resolved_cell()
+            .into(),
         )
     };
 
@@ -82,7 +83,8 @@ pub async fn get_client_runtime_entries(
                 .to_resolved()
                 .await?,
         ))
-        .cell(),
+        .resolved_cell()
+        .into(),
     );
 
     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
@@ -49,7 +51,7 @@ impl AvailableChunkItems {
             .into_iter()
             .map(|(&chunk_item, &info)| async move {
                 Ok(self
-                    .get(chunk_item)
+                    .get(*chunk_item)
                     .await?
                     .is_none()
                     .then_some((chunk_item, info)))
@@ -89,7 +91,8 @@ impl AvailableChunkItems {
         &self,
         chunk_item: Vc<Box<dyn ChunkItem>>,
     ) -> Result<Vc<OptionAvailableChunkItemInfo>> {
-        if let Some(&info) = self.chunk_items.await?.get(&chunk_item) {
+        let resolved_chunk_item = chunk_item.to_resolved().await?;
+        if let Some(&info) = self.chunk_items.await?.get(&resolved_chunk_item) {
             return Ok(Vc::cell(Some(info)));
         };
         if let Some(parent) = self.parent {

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

@@ -2,7 +2,9 @@ use std::collections::HashSet;
 
 use anyhow::Result;
 use auto_hash_map::AutoSet;
-use turbo_tasks::{FxIndexMap, FxIndexSet, TryFlatJoinIterExt, TryJoinIterExt, Value, Vc};
+use turbo_tasks::{
+    FxIndexMap, FxIndexSet, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt, Value, Vc,
+};
 
 use super::{
     availability_info::AvailabilityInfo, available_chunk_items::AvailableChunkItemInfo,
@@ -12,7 +14,7 @@ use super::{
 use crate::{module::Module, output::OutputAssets, reference::ModuleReference};
 
 pub struct MakeChunkGroupResult {
-    pub chunks: Vec<Vc<Box<dyn Chunk>>>,
+    pub chunks: Vec<ResolvedVc<Box<dyn Chunk>>>,
     pub availability_info: AvailabilityInfo,
 }
 
@@ -104,14 +106,17 @@ pub async fn make_chunk_group(
     let availability_info = {
         let map = chunk_items
             .iter()
-            .map(|(&chunk_item, async_info)| {
-                (
-                    chunk_item,
+            .map(|(&chunk_item, async_info)| async move {
+                Ok((
+                    chunk_item.to_resolved().await?,
                     AvailableChunkItemInfo {
                         is_async: async_info.is_some(),
                     },
-                )
+                ))
             })
+            .try_join()
+            .await?
+            .into_iter()
             .collect();
         let map = Vc::cell(map);
         availability_info.with_chunk_items(map).await?
@@ -121,7 +126,7 @@ pub async fn make_chunk_group(
     let async_loaders = async_modules
         .into_iter()
         .map(|module| {
-            chunking_context.async_loader_chunk_item(module, Value::new(availability_info))
+            chunking_context.async_loader_chunk_item(*module, Value::new(availability_info))
         })
         .collect::<Vec<_>>();
     let has_async_loaders = !async_loaders.is_empty();
@@ -164,8 +169,15 @@ pub async fn make_chunk_group(
         chunks.extend(async_loader_chunks.iter().copied());
     }
 
+    // Convert chunks to ResolvedVc
+    let resolved_chunks = chunks
+        .into_iter()
+        .map(|chunk| chunk.to_resolved())
+        .try_join()
+        .await?;
+
     Ok(MakeChunkGroupResult {
-        chunks,
+        chunks: resolved_chunks,
         availability_info,
     })
 }

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

@@ -190,7 +190,7 @@ type AsyncInfo = FxIndexMap<Vc<Box<dyn ChunkItem>>, Vec<Vc<Box<dyn ChunkItem>>>>
 
 pub struct ChunkContentResult {
     pub chunk_items: FxIndexSet<Vc<Box<dyn ChunkItem>>>,
-    pub async_modules: FxIndexSet<Vc<Box<dyn ChunkableModule>>>,
+    pub async_modules: FxIndexSet<ResolvedVc<Box<dyn ChunkableModule>>>,
     pub external_module_references: FxIndexSet<Vc<Box<dyn ModuleReference>>>,
     /// A map from local module to all children from which the async module
     /// status is inherited
@@ -245,7 +245,7 @@ enum ChunkContentGraphNode {
     /// will be inherited.
     InheritAsyncInfo {
         item: Vc<Box<dyn ChunkItem>>,
-        references: Vec<(Vc<Box<dyn ChunkItem>>, InheritAsyncEdge)>,
+        references: Vec<(ResolvedVc<Box<dyn ChunkItem>>, InheritAsyncEdge)>,
     },
 }
 
@@ -413,7 +413,10 @@ async fn graph_node_to_referenced_nodes(
                                         ident: module.ident().to_string().await?,
                                     },
                                 }),
-                                Some((chunk_item, InheritAsyncEdge::LocalModule)),
+                                Some((
+                                    chunk_item.to_resolved().await?,
+                                    InheritAsyncEdge::LocalModule,
+                                )),
                             ))
                         }
                         ChunkingType::Passthrough => {
@@ -590,9 +593,9 @@ async fn chunk_content_internal_parallel(
             Ok(Some(ChunkGraphEdge {
                 key: Some(entry.to_resolved().await?),
                 node: ChunkContentGraphNode::ChunkItem {
-                    item: chunkable_module
+                    item: *chunkable_module
                         .as_chunk_item(chunking_context)
-                        .resolve()
+                        .to_resolved()
                         .await?,
                     ident: chunkable_module.ident().to_string().await?,
                 },
@@ -626,10 +629,10 @@ async fn chunk_content_internal_parallel(
         match graph_node {
             ChunkContentGraphNode::PassthroughChunkItem { .. } => {}
             ChunkContentGraphNode::ChunkItem { item, .. } => {
-                chunk_items.insert(item);
+                chunk_items.insert(*item.to_resolved().await?);
             }
             ChunkContentGraphNode::AsyncModule { module } => {
-                let module = module.resolve().await?;
+                let module = module.to_resolved().await?;
                 async_modules.insert(module);
             }
             ChunkContentGraphNode::ExternalModuleReference(reference) => {
@@ -640,12 +643,12 @@ async fn chunk_content_internal_parallel(
                 for &(reference, ty) in &references {
                     match ty {
                         InheritAsyncEdge::LocalModule => local_back_edges_inherit_async
-                            .entry(reference)
+                            .entry(*reference)
                             .or_insert_with(Vec::new)
                             .push(item),
                         InheritAsyncEdge::AvailableAsyncModule => {
                             available_async_modules_back_edges_inherit_async
-                                .entry(reference)
+                                .entry(*reference)
                                 .or_insert_with(Vec::new)
                                 .push(item)
                         }
@@ -654,7 +657,7 @@ async fn chunk_content_internal_parallel(
                 forward_edges_inherit_async
                     .entry(item)
                     .or_insert_with(Vec::new)
-                    .extend(references.into_iter().map(|(r, _)| r));
+                    .extend(references.into_iter().map(|(r, _)| *r));
             }
         }
     }
@@ -733,17 +736,24 @@ pub struct ChunkItems(pub Vec<Vc<Box<dyn ChunkItem>>>);
 
 #[turbo_tasks::value]
 pub struct AsyncModuleInfo {
-    pub referenced_async_modules: AutoSet<Vc<Box<dyn ChunkItem>>>,
+    pub referenced_async_modules: AutoSet<ResolvedVc<Box<dyn ChunkItem>>>,
 }
 
 #[turbo_tasks::value_impl]
 impl AsyncModuleInfo {
     #[turbo_tasks::function]
-    pub fn new(referenced_async_modules: Vec<Vc<Box<dyn ChunkItem>>>) -> Vc<Self> {
-        Self {
-            referenced_async_modules: referenced_async_modules.into_iter().collect(),
+    pub async fn new(referenced_async_modules: Vec<Vc<Box<dyn ChunkItem>>>) -> Result<Vc<Self>> {
+        let resolved_modules = futures::future::try_join_all(
+            referenced_async_modules
+                .into_iter()
+                .map(|m| m.to_resolved()),
+        )
+        .await?;
+
+        Ok(Self {
+            referenced_async_modules: resolved_modules.into_iter().collect(),
         }
-        .cell()
+        .cell())
     }
 }