perf(turbopack): Use ResolvedVc for turbopack-core

turbopack/crates/turbopack-core/Cargo.toml

@@ -14,6 +14,7 @@ workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
+async-recursion = "1.1.1"
 async-trait = { workspace = true }
 auto-hash-map = { workspace = true }
 browserslist-rs = { workspace = true }

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

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use turbo_tasks::Vc;
+use turbo_tasks::{ResolvedVc, Vc};
 
 use super::available_chunk_items::{AvailableChunkItemInfoMap, AvailableChunkItems};
 
@@ -12,7 +12,7 @@ pub enum AvailabilityInfo {
     Root,
     /// There are modules already available.
     Complete {
-        available_chunk_items: Vc<AvailableChunkItems>,
+        available_chunk_items: ResolvedVc<AvailableChunkItems>,
     },
 }
 
@@ -24,7 +24,7 @@ impl AvailabilityInfo {
             Self::Complete {
                 available_chunk_items,
                 ..
-            } => Some(*available_chunk_items),
+            } => Some(**available_chunk_items),
         }
     }
 
@@ -35,14 +35,14 @@ impl AvailabilityInfo {
         Ok(match self {
             AvailabilityInfo::Untracked => AvailabilityInfo::Untracked,
             AvailabilityInfo::Root => AvailabilityInfo::Complete {
-                available_chunk_items: AvailableChunkItems::new(chunk_items).resolve().await?,
+                available_chunk_items: AvailableChunkItems::new(chunk_items).to_resolved().await?,
             },
             AvailabilityInfo::Complete {
                 available_chunk_items,
             } => AvailabilityInfo::Complete {
                 available_chunk_items: available_chunk_items
                     .with_chunk_items(chunk_items)
-                    .resolve()
+                    .to_resolved()
                     .await?,
             },
         })

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

@@ -27,13 +27,13 @@ pub struct AvailableChunkItemInfoMap(
 #[turbo_tasks::value]
 pub struct AvailableChunkItems {
     parent: Option<ResolvedVc<AvailableChunkItems>>,
-    chunk_items: Vc<AvailableChunkItemInfoMap>,
+    chunk_items: ResolvedVc<AvailableChunkItemInfoMap>,
 }
 
 #[turbo_tasks::value_impl]
 impl AvailableChunkItems {
     #[turbo_tasks::function]
-    pub fn new(chunk_items: Vc<AvailableChunkItemInfoMap>) -> Vc<Self> {
+    pub fn new(chunk_items: ResolvedVc<AvailableChunkItemInfoMap>) -> Vc<Self> {
         AvailableChunkItems {
             parent: None,
             chunk_items,
@@ -44,7 +44,7 @@ impl AvailableChunkItems {
     #[turbo_tasks::function]
     pub async fn with_chunk_items(
         self: ResolvedVc<Self>,
-        chunk_items: Vc<AvailableChunkItemInfoMap>,
+        chunk_items: ResolvedVc<AvailableChunkItemInfoMap>,
     ) -> Result<Vc<Self>> {
         let chunk_items = chunk_items
             .await?
@@ -60,7 +60,7 @@ impl AvailableChunkItems {
             .await?;
         Ok(AvailableChunkItems {
             parent: Some(self),
-            chunk_items: Vc::cell(chunk_items.into_iter().collect()),
+            chunk_items: ResolvedVc::cell(chunk_items.into_iter().collect()),
         }
         .cell())
     }

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

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use turbo_rcstr::RcStr;
-use turbo_tasks::{ReadRef, TryJoinIterExt, Vc};
+use turbo_tasks::{ReadRef, ResolvedVc, TryJoinIterExt, Vc};
 use turbo_tasks_fs::FileSystemPath;
 
 use crate::{
@@ -14,7 +14,7 @@ pub struct ChunkData {
     pub included: Vec<ReadRef<ModuleId>>,
     pub excluded: Vec<ReadRef<ModuleId>>,
     pub module_chunks: Vec<String>,
-    pub references: Vc<OutputAssets>,
+    pub references: ResolvedVc<OutputAssets>,
 }
 
 #[turbo_tasks::value(transparent)]
@@ -57,7 +57,7 @@ impl ChunkData {
                     included: Vec::new(),
                     excluded: Vec::new(),
                     module_chunks: Vec::new(),
-                    references: OutputAssets::empty(),
+                    references: OutputAssets::empty().to_resolved().await?,
                 }
                 .cell(),
             )));
@@ -112,7 +112,7 @@ impl ChunkData {
                 included,
                 excluded,
                 module_chunks,
-                references: Vc::cell(module_chunks_references),
+                references: ResolvedVc::cell(module_chunks_references),
             }
             .cell(),
         )))
@@ -139,6 +139,6 @@ impl ChunkData {
     /// Returns [`OutputAsset`]s that this chunk data references.
     #[turbo_tasks::function]
     pub fn references(&self) -> Vc<OutputAssets> {
-        self.references
+        *self.references
     }
 }

turbopack/crates/turbopack-core/src/compile_time_info.rs

@@ -1,3 +1,4 @@
+use anyhow::Result;
 use turbo_rcstr::RcStr;
 use turbo_tasks::{FxIndexMap, ResolvedVc, Vc};
 use turbo_tasks_fs::FileSystemPath;
@@ -267,13 +268,13 @@ impl FreeVarReferences {
 #[turbo_tasks::value(shared)]
 #[derive(Debug, Clone)]
 pub struct CompileTimeInfo {
-    pub environment: Vc<Environment>,
-    pub defines: Vc<CompileTimeDefines>,
-    pub free_var_references: Vc<FreeVarReferences>,
+    pub environment: ResolvedVc<Environment>,
+    pub defines: ResolvedVc<CompileTimeDefines>,
+    pub free_var_references: ResolvedVc<FreeVarReferences>,
 }
 
 impl CompileTimeInfo {
-    pub fn builder(environment: Vc<Environment>) -> CompileTimeInfoBuilder {
+    pub fn builder(environment: ResolvedVc<Environment>) -> CompileTimeInfoBuilder {
         CompileTimeInfoBuilder {
             environment,
             defines: None,
@@ -285,50 +286,57 @@ impl CompileTimeInfo {
 #[turbo_tasks::value_impl]
 impl CompileTimeInfo {
     #[turbo_tasks::function]
-    pub fn new(environment: Vc<Environment>) -> Vc<Self> {
-        CompileTimeInfo {
+    pub async fn new(environment: ResolvedVc<Environment>) -> Result<Vc<Self>> {
+        Ok(CompileTimeInfo {
             environment,
-            defines: CompileTimeDefines::empty(),
-            free_var_references: FreeVarReferences::empty(),
+            defines: CompileTimeDefines::empty().to_resolved().await?,
+            free_var_references: FreeVarReferences::empty().to_resolved().await?,
         }
-        .cell()
+        .cell())
     }
 
     #[turbo_tasks::function]
     pub fn environment(&self) -> Vc<Environment> {
-        self.environment
+        *self.environment
     }
 }
 
 pub struct CompileTimeInfoBuilder {
-    environment: Vc<Environment>,
-    defines: Option<Vc<CompileTimeDefines>>,
-    free_var_references: Option<Vc<FreeVarReferences>>,
+    environment: ResolvedVc<Environment>,
+    defines: Option<ResolvedVc<CompileTimeDefines>>,
+    free_var_references: Option<ResolvedVc<FreeVarReferences>>,
 }
 
 impl CompileTimeInfoBuilder {
-    pub fn defines(mut self, defines: Vc<CompileTimeDefines>) -> Self {
+    pub fn defines(mut self, defines: ResolvedVc<CompileTimeDefines>) -> Self {
         self.defines = Some(defines);
         self
     }
 
-    pub fn free_var_references(mut self, free_var_references: Vc<FreeVarReferences>) -> Self {
+    pub fn free_var_references(
+        mut self,
+        free_var_references: ResolvedVc<FreeVarReferences>,
+    ) -> Self {
         self.free_var_references = Some(free_var_references);
         self
     }
 
-    pub fn build(self) -> CompileTimeInfo {
-        CompileTimeInfo {
+    pub async fn build(self) -> Result<CompileTimeInfo> {
+        Ok(CompileTimeInfo {
             environment: self.environment,
-            defines: self.defines.unwrap_or_else(CompileTimeDefines::empty),
-            free_var_references: self
-                .free_var_references
-                .unwrap_or_else(FreeVarReferences::empty),
-        }
+            defines: match self.defines {
+                Some(defines) => defines,
+                None => CompileTimeDefines::empty().to_resolved().await?,
+            },
+            free_var_references: match self.free_var_references {
+                Some(free_var_references) => free_var_references,
+                None => FreeVarReferences::empty().to_resolved().await?,
+            },
+        })
     }
 
-    pub fn cell(self) -> Vc<CompileTimeInfo> {
-        self.build().cell()
+    pub async fn cell(self) -> Result<Vc<CompileTimeInfo>> {
+        Ok(self.build().await?.cell())
     }
 }
 

turbopack/crates/turbopack-core/src/environment.rs

@@ -70,7 +70,7 @@ impl Environment {
     pub async fn compile_target(&self) -> Result<Vc<CompileTarget>> {
         Ok(match self.execution {
             ExecutionEnvironment::NodeJsBuildTime(node_env, ..)
-            | ExecutionEnvironment::NodeJsLambda(node_env) => node_env.await?.compile_target,
+            | ExecutionEnvironment::NodeJsLambda(node_env) => *node_env.await?.compile_target,
             ExecutionEnvironment::Browser(_) => CompileTarget::unknown(),
             ExecutionEnvironment::EdgeWorker(_) => CompileTarget::unknown(),
             ExecutionEnvironment::Custom(_) => todo!(),
@@ -189,7 +189,7 @@ impl Environment {
         let env = self;
         Ok(match env.execution {
             ExecutionEnvironment::NodeJsBuildTime(env)
-            | ExecutionEnvironment::NodeJsLambda(env) => env.await?.cwd,
+            | ExecutionEnvironment::NodeJsLambda(env) => *env.await?.cwd,
             _ => Vc::cell(None),
         })
     }
@@ -227,20 +227,10 @@ pub enum NodeEnvironmentType {
 
 #[turbo_tasks::value(shared)]
 pub struct NodeJsEnvironment {
-    pub compile_target: Vc<CompileTarget>,
-    pub node_version: Vc<NodeJsVersion>,
+    pub compile_target: ResolvedVc<CompileTarget>,
+    pub node_version: ResolvedVc<NodeJsVersion>,
     // user specified process.cwd
-    pub cwd: Vc<Option<RcStr>>,
-}
-
-impl Default for NodeJsEnvironment {
-    fn default() -> Self {
-        NodeJsEnvironment {
-            compile_target: CompileTarget::current(),
-            node_version: NodeJsVersion::default().cell(),
-            cwd: Vc::cell(None),
-        }
-    }
+    pub cwd: ResolvedVc<Option<RcStr>>,
 }
 
 #[turbo_tasks::value_impl]
@@ -262,12 +252,14 @@ impl NodeJsEnvironment {
     }
 
     #[turbo_tasks::function]
-    pub fn current(process_env: ResolvedVc<Box<dyn ProcessEnv>>) -> Vc<Self> {
-        Self::cell(NodeJsEnvironment {
-            compile_target: CompileTarget::current(),
-            node_version: NodeJsVersion::cell(NodeJsVersion::Current(process_env)),
-            cwd: Vc::cell(None),
-        })
+    pub async fn current(process_env: ResolvedVc<Box<dyn ProcessEnv>>) -> Result<Vc<Self>> {
+        Ok(Self::cell(NodeJsEnvironment {
+            compile_target: CompileTarget::current().to_resolved().await?,
+            node_version: NodeJsVersion::cell(NodeJsVersion::Current(process_env))
+                .to_resolved()
+                .await?,
+            cwd: ResolvedVc::cell(None),
+        }))
     }
 }
 

turbopack/crates/turbopack-core/src/file_source.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use turbo_rcstr::RcStr;
-use turbo_tasks::Vc;
+use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::{FileContent, FileSystemEntryType, FileSystemPath, LinkContent};
 
 use crate::{
@@ -13,22 +13,22 @@ use crate::{
 /// references to other [Source]s.
 #[turbo_tasks::value]
 pub struct FileSource {
-    pub path: Vc<FileSystemPath>,
-    pub query: Vc<RcStr>,
+    pub path: ResolvedVc<FileSystemPath>,
+    pub query: ResolvedVc<RcStr>,
 }
 
 #[turbo_tasks::value_impl]
 impl FileSource {
     #[turbo_tasks::function]
-    pub fn new(path: Vc<FileSystemPath>) -> Vc<Self> {
+    pub fn new(path: ResolvedVc<FileSystemPath>) -> Vc<Self> {
         Self::cell(FileSource {
             path,
-            query: Vc::<RcStr>::default(),
+            query: ResolvedVc::cell(RcStr::default()),
         })
     }
 
     #[turbo_tasks::function]
-    pub fn new_with_query(path: Vc<FileSystemPath>, query: Vc<RcStr>) -> Vc<Self> {
+    pub fn new_with_query(path: ResolvedVc<FileSystemPath>, query: ResolvedVc<RcStr>) -> Vc<Self> {
         Self::cell(FileSource { path, query })
     }
 }
@@ -37,7 +37,7 @@ impl FileSource {
 impl Source for FileSource {
     #[turbo_tasks::function]
     fn ident(&self) -> Vc<AssetIdent> {
-        AssetIdent::from_path(self.path).with_query(self.query)
+        AssetIdent::from_path(*self.path).with_query(*self.query)
     }
 }