perf(turbopack): Use ResolvedVc for turbopack-env

turbopack/crates/turbopack-env/src/asset.rs

@@ -1,7 +1,7 @@
 use std::io::Write;
 
 use anyhow::Result;
-use turbo_tasks::Vc;
+use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_env::ProcessEnv;
 use turbo_tasks_fs::{rope::RopeBuilder, File, FileSystemPath};
 use turbopack_core::{
@@ -16,17 +16,20 @@ use turbopack_ecmascript::utils::StringifyJs;
 #[turbo_tasks::value]
 pub struct ProcessEnvAsset {
     /// The root path which we can construct our env asset path.
-    root: Vc<FileSystemPath>,
+    root: ResolvedVc<FileSystemPath>,
 
     /// A HashMap filled with the env key/values.
-    env: Vc<Box<dyn ProcessEnv>>,
+    env: ResolvedVc<Box<dyn ProcessEnv>>,
 }
 
 #[turbo_tasks::value_impl]
 impl ProcessEnvAsset {
     #[turbo_tasks::function]
-    pub fn new(root: Vc<FileSystemPath>, env: Vc<Box<dyn ProcessEnv>>) -> Vc<Self> {
-        ProcessEnvAsset { root, env }.cell()
+    pub async fn new(
+        root: ResolvedVc<FileSystemPath>,
+        env: ResolvedVc<Box<dyn ProcessEnv>>,
+    ) -> Result<Vc<Self>> {
+        Ok(ProcessEnvAsset { root, env }.cell())
     }
 }
 

turbopack/crates/turbopack-env/src/embeddable.rs

@@ -1,21 +1,21 @@
 use anyhow::Result;
 use turbo_rcstr::RcStr;
-use turbo_tasks::Vc;
+use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_env::{EnvMap, ProcessEnv};
 use turbopack_ecmascript::utils::StringifyJs;
 
 /// Encodes values as JS strings so that they can be safely injected into a JS
 /// output.
 #[turbo_tasks::value]
 pub struct EmbeddableProcessEnv {
-    prior: Vc<Box<dyn ProcessEnv>>,
+    prior: ResolvedVc<Box<dyn ProcessEnv>>,
 }
 
 #[turbo_tasks::value_impl]
 impl EmbeddableProcessEnv {
     #[turbo_tasks::function]
-    pub fn new(prior: Vc<Box<dyn ProcessEnv>>) -> Vc<Self> {
-        EmbeddableProcessEnv { prior }.cell()
+    pub fn new(prior: ResolvedVc<Box<dyn ProcessEnv>>) -> Result<Vc<Self>> {
+        Ok(EmbeddableProcessEnv { prior }.cell())
     }
 }
 

turbopack/crates/turbopack-env/src/issue.rs

@@ -1,12 +1,12 @@
-use turbo_tasks::Vc;
+use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::issue::{Issue, IssueStage, OptionStyledString, StyledString};
 
 /// An issue that occurred while resolving the parsing or evaluating the .env.
 #[turbo_tasks::value(shared)]
 pub struct ProcessEnvIssue {
-    pub path: Vc<FileSystemPath>,
-    pub description: Vc<StyledString>,
+    pub path: ResolvedVc<FileSystemPath>,
+    pub description: ResolvedVc<StyledString>,
 }
 
 #[turbo_tasks::value_impl]
@@ -23,11 +23,11 @@ impl Issue for ProcessEnvIssue {
 
     #[turbo_tasks::function]
     fn file_path(&self) -> Vc<FileSystemPath> {
-        self.path
+        *self.path
     }
 
     #[turbo_tasks::function]
     fn description(&self) -> Vc<OptionStyledString> {
-        Vc::cell(Some(self.description))
+        Vc::cell(Some(*self.description))
     }
 }

turbopack/crates/turbopack-env/src/try_env.rs

@@ -1,5 +1,5 @@
 use anyhow::Result;
-use turbo_tasks::Vc;
+use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_env::{DotenvProcessEnv, EnvMap, ProcessEnv};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::issue::{IssueExt, StyledString};
@@ -8,22 +8,27 @@ use crate::ProcessEnvIssue;
 
 #[turbo_tasks::value]
 pub struct TryDotenvProcessEnv {
-    dotenv: Vc<DotenvProcessEnv>,
-    prior: Vc<Box<dyn ProcessEnv>>,
-    path: Vc<FileSystemPath>,
+    dotenv: ResolvedVc<DotenvProcessEnv>,
+    prior: ResolvedVc<Box<dyn ProcessEnv>>,
+    path: ResolvedVc<FileSystemPath>,
 }
 
 #[turbo_tasks::value_impl]
 impl TryDotenvProcessEnv {
     #[turbo_tasks::function]
-    pub fn new(prior: Vc<Box<dyn ProcessEnv>>, path: Vc<FileSystemPath>) -> Vc<Self> {
-        let dotenv = DotenvProcessEnv::new(Some(prior), path);
-        TryDotenvProcessEnv {
+    pub async fn new(
+        prior: ResolvedVc<Box<dyn ProcessEnv>>,
+        path: ResolvedVc<FileSystemPath>,
+    ) -> Result<Vc<Self>> {
+        let dotenv = DotenvProcessEnv::new(Some(*prior), *path)
+            .to_resolved()
+            .await?;
+        Ok(TryDotenvProcessEnv {
             dotenv,
             prior,
             path,
         }
-        .cell()
+        .cell())
     }
 }
 
@@ -50,7 +55,8 @@ impl ProcessEnv for TryDotenvProcessEnv {
                     // read_all_with_prior will wrap a current error with a context containing the
                     // failing file, which we don't really care about (we report the filepath as the
                     // Issue context, not the description). So extract the real error.
-                    description: StyledString::Text(e.root_cause().to_string().into()).cell(),
+                    description: StyledString::Text(e.root_cause().to_string().into())
+                        .resolved_cell(),
                 }
                 .cell()
                 .emit();