perf(turbopack): Use Arc<String> instead of String

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

@@ -188,7 +188,7 @@ impl Args {
 }
 
 async fn create_fs(name: &str, root: &str, watch: bool) -> Result<Vc<Box<dyn FileSystem>>> {
-    let fs = DiskFileSystem::new(name.to_string(), root.to_string(), vec![]);
+    let fs = DiskFileSystem::new(name.to_string().into(), root.to_string().into(), vec![]);
     if watch {
         fs.await?.start_watching()?;
     } else {
@@ -232,17 +232,18 @@ async fn add_glob_results(
 #[turbo_tasks::function]
 async fn input_to_modules(
     fs: Vc<Box<dyn FileSystem>>,
-    input: Vec<String>,
+    input: Vec<Arc<String>>,
     exact: bool,
-    process_cwd: Option<String>,
-    context_directory: String,
+    process_cwd: Option<Arc<String>>,
+    context_directory: Arc<String>,
     module_options: TransientInstance<ModuleOptionsContext>,
     resolve_options: TransientInstance<ResolveOptionsContext>,
 ) -> Result<Vc<Modules>> {
     let root = fs.root();
     let process_cwd = process_cwd
         .clone()
-        .map(|p| format!("/ROOT{}", p.trim_start_matches(&context_directory)));
+        .map(|p| format!("/ROOT{}", p.trim_start_matches(&*context_directory)))
+        .map(Arc::new);
 
     let asset_context: Vc<Box<dyn AssetContext>> = Vc::upcast(create_module_asset(
         root,
@@ -283,7 +284,7 @@ fn process_context(dir: &Path, context_directory: Option<&String>) -> Result<Str
         .to_string())
 }
 
-fn make_relative_path(dir: &Path, context_directory: &str, input: &str) -> Result<String> {
+fn make_relative_path(dir: &Path, context_directory: &str, input: &str) -> Result<Arc<String>> {
     let mut input = PathBuf::from(input);
     if !input.is_absolute() {
         input = dir.join(input);
@@ -299,10 +300,15 @@ fn make_relative_path(dir: &Path, context_directory: &str, input: &str) -> Resul
     Ok(input
         .to_str()
         .ok_or_else(|| anyhow!("input contains invalid characters"))?
-        .replace('\\', "/"))
+        .replace('\\', "/")
+        .into())
 }
 
-fn process_input(dir: &Path, context_directory: &str, input: &[String]) -> Result<Vec<String>> {
+fn process_input(
+    dir: &Path,
+    context_directory: &str,
+    input: &[String],
+) -> Result<Vec<Arc<String>>> {
     input
         .iter()
         .map(|input| make_relative_path(dir, context_directory, input))
@@ -537,8 +543,8 @@ async fn main_operation(
                 fs,
                 input,
                 exact,
-                process_cwd.clone(),
-                context_directory,
+                process_cwd.clone().map(Arc::new),
+                context_directory.into(),
                 module_options,
                 resolve_options,
             )
@@ -563,8 +569,8 @@ async fn main_operation(
                 fs,
                 input,
                 exact,
-                process_cwd.clone(),
-                context_directory,
+                process_cwd.clone().map(Arc::new),
+                context_directory.into(),
                 module_options,
                 resolve_options,
             )
@@ -573,7 +579,7 @@ async fn main_operation(
             {
                 let nft_asset = NftJsonAsset::new(*module);
                 let path = nft_asset.ident().path().await?.path.clone();
-                output_nft_assets.push(path);
+                output_nft_assets.push((*path).clone());
                 emits.push(emit_asset(Vc::upcast(nft_asset)));
             }
             // Wait for all files to be emitted
@@ -596,8 +602,8 @@ async fn main_operation(
                 fs,
                 input,
                 exact,
-                process_cwd.clone(),
-                context_directory,
+                process_cwd.clone().map(Arc::new),
+                context_directory.into(),
                 module_options,
                 resolve_options,
             )
@@ -620,13 +626,13 @@ async fn main_operation(
 #[turbo_tasks::function]
 async fn create_module_asset(
     root: Vc<FileSystemPath>,
-    process_cwd: Option<String>,
+    process_cwd: Option<Arc<String>>,
     module_options: TransientInstance<ModuleOptionsContext>,
     resolve_options: TransientInstance<ResolveOptionsContext>,
 ) -> Result<Vc<ModuleAssetContext>> {
     let env = Environment::new(Value::new(ExecutionEnvironment::NodeJsLambda(
         NodeJsEnvironment {
-            cwd: Vc::cell(process_cwd),
+            cwd: Vc::cell(process_cwd.as_deref().cloned()),
             ..Default::default()
         }
         .into(),
@@ -635,12 +641,12 @@ async fn create_module_asset(
     let glob_mappings = vec![
         (
             root,
-            Glob::new("**/*/next/dist/server/next.js".to_string()),
+            Glob::new("**/*/next/dist/server/next.js".to_string().into()),
             ImportMapping::Ignore.into(),
         ),
         (
             root,
-            Glob::new("**/*/next/dist/bin/next".to_string()),
+            Glob::new("**/*/next/dist/bin/next".to_string().into()),
             ImportMapping::Ignore.into(),
         ),
     ];

crates/node-file-trace/src/nft_json.rs

@@ -29,7 +29,9 @@ impl OutputAsset for NftJsonAsset {
     async fn ident(&self) -> Result<Vc<AssetIdent>> {
         let path = self.entry.ident().path().await?;
         Ok(AssetIdent::from_path(
-            path.fs.root().join(format!("{}.nft.json", path.path)),
+            path.fs
+                .root()
+                .join(format!("{}.nft.json", path.path).into()),
         ))
     }
 }

crates/turbo-tasks-env/src/custom.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use anyhow::Result;
 use turbo_tasks::Vc;
 
@@ -32,7 +34,7 @@ impl ProcessEnv for CustomProcessEnv {
     }
 
     #[turbo_tasks::function]
-    async fn read(&self, name: String) -> Result<Vc<Option<String>>> {
+    async fn read(&self, name: Arc<String>) -> Result<Vc<Option<String>>> {
         let custom = case_insensitive_read(self.custom, name.clone());
         match &*custom.await? {
             Some(_) => Ok(custom),

crates/turbo-tasks-env/src/filter.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use anyhow::Result;
 use indexmap::IndexMap;
 use turbo_tasks::Vc;
@@ -15,7 +17,7 @@ pub struct FilterProcessEnv {
 #[turbo_tasks::value_impl]
 impl FilterProcessEnv {
     #[turbo_tasks::function]
-    pub fn new(prior: Vc<Box<dyn ProcessEnv>>, filters: Vec<String>) -> Vc<Self> {
+    pub fn new(prior: Vc<Box<dyn ProcessEnv>>, filters: Vec<Arc<String>>) -> Vc<Self> {
         FilterProcessEnv {
             prior,
             filters: filters.into_iter().map(|f| f.to_uppercase()).collect(),
@@ -43,7 +45,7 @@ impl ProcessEnv for FilterProcessEnv {
     }
 
     #[turbo_tasks::function]
-    fn read(&self, name: String) -> Vc<Option<String>> {
+    fn read(&self, name: Arc<String>) -> Vc<Option<String>> {
         for filter in &self.filters {
             if name.to_uppercase().starts_with(filter) {
                 return self.prior.read(name);

crates/turbo-tasks-env/src/lib.rs

@@ -5,7 +5,10 @@ mod custom;
 mod dotenv;
 mod filter;
 
-use std::{env, sync::Mutex};
+use std::{
+    env,
+    sync::{Arc, Mutex},
+};
 
 use anyhow::Result;
 use indexmap::IndexMap;
@@ -35,7 +38,7 @@ impl ProcessEnv for EnvMap {
     }
 
     #[turbo_tasks::function]
-    async fn read(self: Vc<Self>, name: String) -> Vc<Option<String>> {
+    async fn read(self: Vc<Self>, name: Arc<String>) -> Vc<Option<String>> {
         case_insensitive_read(self, name)
     }
 }
@@ -51,7 +54,7 @@ pub trait ProcessEnv {
     fn read_all(self: Vc<Self>) -> Vc<EnvMap>;
 
     /// Reads a single env variable. Ignores casing.
-    fn read(self: Vc<Self>, name: String) -> Vc<Option<String>> {
+    fn read(self: Vc<Self>, name: Arc<String>) -> Vc<Option<String>> {
         case_insensitive_read(self.read_all(), name)
     }
 }
@@ -63,7 +66,10 @@ pub fn sorted_env_vars() -> IndexMap<String, String> {
 }
 
 #[turbo_tasks::function]
-pub async fn case_insensitive_read(map: Vc<EnvMap>, name: String) -> Result<Vc<Option<String>>> {
+pub async fn case_insensitive_read(
+    map: Vc<EnvMap>,
+    name: Arc<String>,
+) -> Result<Vc<Option<String>>> {
     Ok(Vc::cell(
         to_uppercase_map(map)
             .await?

crates/turbo-tasks-fetch/tests/fetch.rs

@@ -141,5 +141,5 @@ async fn errors_on_404() {
 }
 
 fn get_issue_context() -> Vc<FileSystemPath> {
-    DiskFileSystem::new("root".to_owned(), "/".to_owned(), vec![]).root()
+    DiskFileSystem::new("root".to_owned().into(), "/".to_owned().into(), vec![]).root()
 }

crates/turbo-tasks-fs/examples/hash_directory.rs

@@ -30,12 +30,12 @@ async fn main() -> Result<()> {
     let task = tt.spawn_root_task(|| {
         Box::pin(async {
             let root = current_dir().unwrap().to_str().unwrap().to_string();
-            let disk_fs = DiskFileSystem::new("project".to_string(), root, vec![]);
+            let disk_fs = DiskFileSystem::new("project".to_string().into(), root.into(), vec![]);
             disk_fs.await?.start_watching()?;
 
             // Smart Pointer cast
             let fs: Vc<Box<dyn FileSystem>> = Vc::upcast(disk_fs);
-            let input = fs.root().join("demo".to_string());
+            let input = fs.root().join("demo".to_string().into());
             let dir_hash = hash_directory(input);
             print_hash(dir_hash).await?;
             Ok::<Vc<()>, _>(Default::default())

crates/turbo-tasks-fs/examples/hash_glob.rs

@@ -27,13 +27,13 @@ async fn main() -> Result<()> {
     let task = tt.spawn_root_task(|| {
         Box::pin(async {
             let root = current_dir().unwrap().to_str().unwrap().to_string();
-            let disk_fs = DiskFileSystem::new("project".to_string(), root, vec![]);
+            let disk_fs = DiskFileSystem::new("project".to_string().into(), root.into(), vec![]);
             disk_fs.await?.start_watching()?;
 
             // Smart Pointer cast
             let fs: Vc<Box<dyn FileSystem>> = Vc::upcast(disk_fs);
-            let input = fs.root().join("crates".to_string());
-            let glob = Glob::new("**/*.rs".to_string());
+            let input = fs.root().join("crates".to_string().into());
+            let glob = Glob::new("**/*.rs".to_string().into());
             let glob_result = input.read_glob(glob, true);
             let dir_hash = hash_glob_result(glob_result);
             print_hash(dir_hash).await?;

crates/turbo-tasks-fs/src/attach.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use anyhow::{bail, Result};
 use auto_hash_map::AutoMap;
 use turbo_tasks::{Completion, ValueToString, Vc};
@@ -16,7 +18,7 @@ pub struct AttachedFileSystem {
     root_fs: Vc<Box<dyn FileSystem>>,
     // we turn this into a string because creating a FileSystemPath requires the filesystem which
     // we are creating (circular reference)
-    child_path: String,
+    child_path: Arc<String>,
     child_fs: Vc<Box<dyn FileSystem>>,
 }
 
@@ -112,7 +114,7 @@ impl AttachedFileSystem {
                 .root()
                 .resolve()
                 .await?
-                .join(inner_path.to_string())
+                .join(inner_path.to_string().into())
         } else {
             this.root_fs.root().resolve().await?.join(path.path.clone())
         })

crates/turbo-tasks-fs/src/embed/dir.rs

@@ -2,14 +2,14 @@ pub use ::include_dir::{
     include_dir, {self},
 };
 use anyhow::Result;
-use turbo_tasks::{TransientInstance, Vc};
+use turbo_tasks::{RcStr, TransientInstance, Vc};
 
 use crate::{embed::EmbeddedFileSystem, DiskFileSystem, FileSystem};
 
 #[turbo_tasks::function]
 pub async fn directory_from_relative_path(
-    name: String,
-    path: String,
+    name: RcStr,
+    path: RcStr,
 ) -> Result<Vc<Box<dyn FileSystem>>> {
     let disk_fs = DiskFileSystem::new(name, path, vec![]);
     disk_fs.await?.start_watching()?;
@@ -19,7 +19,7 @@ pub async fn directory_from_relative_path(
 
 #[turbo_tasks::function]
 pub async fn directory_from_include_dir(
-    name: String,
+    name: RcStr,
     dir: TransientInstance<&'static include_dir::Dir<'static>>,
 ) -> Result<Vc<Box<dyn FileSystem>>> {
     Ok(Vc::upcast(EmbeddedFileSystem::new(name, dir)))
@@ -72,7 +72,7 @@ macro_rules! embed_directory_internal {
         static dir: include_dir::Dir<'static> = turbo_tasks_fs::embed::include_dir!($path);
 
         turbo_tasks_fs::embed::directory_from_include_dir(
-            $name.to_string(),
+            $name.to_string().into(),
             turbo_tasks::TransientInstance::new(&dir),
         )
     }};

crates/turbo-tasks-fs/src/embed/file.rs

@@ -1,37 +1,34 @@
-use std::path::PathBuf;
+use std::{path::Path, sync::Arc};
 
 use anyhow::{Context, Result};
 use dunce::canonicalize;
-use turbo_tasks::Vc;
+use turbo_tasks::{RcStr, Vc};
 
 use crate::{DiskFileSystem, File, FileContent, FileSystem};
 
 #[turbo_tasks::function]
 pub async fn content_from_relative_path(
-    package_path: String,
-    path: String,
+    package_path: Arc<String>,
+    path: Arc<String>,
 ) -> Result<Vc<FileContent>> {
-    let package_path = PathBuf::from(package_path);
-    let resolved_path = package_path.join(path);
+    let package_path = Path::new(&**package_path);
+    let resolved_path = package_path.join(&**path);
     let resolved_path =
         canonicalize(&resolved_path).context("failed to canonicalize embedded file path")?;
     let root_path = resolved_path.parent().unwrap();
     let path = resolved_path.file_name().unwrap().to_str().unwrap();
 
-    let disk_fs = DiskFileSystem::new(
-        root_path.to_string_lossy().to_string(),
-        root_path.to_string_lossy().to_string(),
-        vec![],
-    );
+    let root_path_str = Arc::new(root_path.to_string_lossy().to_string());
+    let disk_fs = DiskFileSystem::new(root_path_str.clone(), root_path_str, vec![]);
     disk_fs.await?.start_watching()?;
 
-    let fs_path = disk_fs.root().join(path.to_string());
+    let fs_path = disk_fs.root().join(path.to_string().into());
     Ok(fs_path.read())
 }
 
 #[turbo_tasks::function]
-pub async fn content_from_str(string: String) -> Result<Vc<FileContent>> {
+pub async fn content_from_str(string: RcStr) -> Result<Vc<FileContent>> {
     Ok(File::from(string).into())
 }
 
 /// Loads a file's content from disk and invalidates on change (debug builds).
@@ -57,7 +54,9 @@
 macro_rules! embed_file {
     ($path:expr) => {
         turbo_tasks_fs::embed::content_from_str(
-            include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/", $path)).to_string(),
+            include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/", $path))
+                .to_string()
+                .into(),
         )
     };
 }