change turbopack-cli to new backend (#75242)

### What?

* change turbopack-cli to new backend
* avoid transient tasks in turbopack-cli

Author: sokra

Cargo.lock

@@ -45,11 +45,11 @@ tokio = { workspace = true, features = ["full"] }
 tracing-subscriber = { workspace = true, features = ["env-filter", "json"] }
 turbo-rcstr = { workspace = true }
 turbo-tasks = { workspace = true }
+turbo-tasks-backend = { workspace = true }
 turbo-tasks-env = { workspace = true }
 turbo-tasks-fetch = { workspace = true }
 turbo-tasks-fs = { workspace = true }
 turbo-tasks-malloc = { workspace = true, default-features = false }
-turbo-tasks-memory = { workspace = true }
 turbopack = { workspace = true }
 turbopack-browser = { workspace = true }
 turbopack-cli-utils = { workspace = true }

turbopack/crates/turbopack-cli/Cargo.toml

@@ -77,12 +77,11 @@ pub struct CommonArguments {
     #[clap(long)]
     pub full_stats: bool,
 
-    /// Enable experimental garbage collection with the provided memory limit in
-    /// MB.
-    #[clap(long)]
-    pub memory_limit: Option<usize>,
-
-    /// Target
+    // Enable experimental garbage collection with the provided memory limit in
+    // MB.
+    // #[clap(long)]
+    // pub memory_limit: Option<usize>,
+    /// Whether to build for the `browser` or `node``
     #[clap(long)]
     pub target: Option<Target>,
 }

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

@@ -11,8 +11,10 @@ use turbo_tasks::{
     apply_effects, ReadConsistency, ResolvedVc, TransientInstance, TryJoinIterExt, TurboTasks,
     Value, Vc,
 };
+use turbo_tasks_backend::{
+    noop_backing_storage, BackendOptions, NoopBackingStorage, TurboTasksBackend,
+};
 use turbo_tasks_fs::FileSystem;
-use turbo_tasks_memory::MemoryBackend;
 use turbopack_browser::BrowserChunkingContext;
 use turbopack_cli_utils::issue::{ConsoleUi, LogOptions};
 use turbopack_core::{
@@ -43,8 +45,7 @@ use crate::{
     arguments::{BuildArguments, Target},
     contexts::{get_client_asset_context, get_client_compile_time_info, NodeEnv},
     util::{
-        normalize_dirs, normalize_entries, output_fs, project_fs, EntryRequest, EntryRequests,
-        NormalizedDirs,
+        normalize_dirs, normalize_entries, output_fs, project_fs, EntryRequest, NormalizedDirs,
     },
 };
 
@@ -53,8 +54,10 @@ pub fn register() {
     include!(concat!(env!("OUT_DIR"), "/register.rs"));
 }
 
+type Backend = TurboTasksBackend<NoopBackingStorage>;
+
 pub struct TurbopackBuildBuilder {
-    turbo_tasks: Arc<TurboTasks<MemoryBackend>>,
+    turbo_tasks: Arc<TurboTasks<Backend>>,
     project_dir: RcStr,
     root_dir: RcStr,
     entry_requests: Vec<EntryRequest>,
@@ -67,11 +70,7 @@ pub struct TurbopackBuildBuilder {
 }
 
 impl TurbopackBuildBuilder {
-    pub fn new(
-        turbo_tasks: Arc<TurboTasks<MemoryBackend>>,
-        project_dir: RcStr,
-        root_dir: RcStr,
-    ) -> Self {
+    pub fn new(turbo_tasks: Arc<TurboTasks<Backend>>, project_dir: RcStr, root_dir: RcStr) -> Self {
         TurbopackBuildBuilder {
             turbo_tasks,
             project_dir,
@@ -126,14 +125,7 @@ impl TurbopackBuildBuilder {
             let build_result_op = build_internal(
                 self.project_dir.clone(),
                 self.root_dir,
-                EntryRequests(
-                    self.entry_requests
-                        .iter()
-                        .cloned()
-                        .map(EntryRequest::resolved_cell)
-                        .collect(),
-                )
-                .resolved_cell(),
+                self.entry_requests.clone(),
                 self.browserslist_query,
                 self.minify_type,
                 self.target,
@@ -177,7 +169,7 @@ impl TurbopackBuildBuilder {
 async fn build_internal(
     project_dir: RcStr,
     root_dir: RcStr,
-    entry_requests: ResolvedVc<EntryRequests>,
+    entry_requests: Vec<EntryRequest>,
     browserslist_query: RcStr,
     minify_type: MinifyType,
     target: Target,
@@ -285,11 +277,9 @@ async fn build_internal(
     );
 
     let entry_requests = (*entry_requests
-        .await?
-        .iter()
-        .cloned()
+        .into_iter()
         .map(|r| async move {
-            Ok(match &*r.await? {
+            Ok(match r {
                 EntryRequest::Relative(p) => Request::relative(
                     Value::new(p.clone().into()),
                     Default::default(),
@@ -421,10 +411,12 @@ pub async fn build(args: &BuildArguments) -> Result<()> {
         root_dir,
     } = normalize_dirs(&args.common.dir, &args.common.root)?;
 
-    let tt = TurboTasks::new(MemoryBackend::new(
-        args.common
-            .memory_limit
-            .map_or(usize::MAX, |l| l * 1024 * 1024),
+    let tt = TurboTasks::new(TurboTasksBackend::new(
+        BackendOptions {
+            storage_mode: None,
+            ..Default::default()
+        },
+        noop_backing_storage(),
     ));
 
     let mut builder = TurbopackBuildBuilder::new(tt, project_dir, root_dir)

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

@@ -16,9 +16,11 @@ use turbo_tasks::{
     util::{FormatBytes, FormatDuration},
     ResolvedVc, TransientInstance, TurboTasks, UpdateInfo, Value, Vc,
 };
+use turbo_tasks_backend::{
+    noop_backing_storage, BackendOptions, NoopBackingStorage, TurboTasksBackend,
+};
 use turbo_tasks_fs::FileSystem;
 use turbo_tasks_malloc::TurboMalloc;
-use turbo_tasks_memory::MemoryBackend;
 use turbopack::evaluate_context::node_build_environment;
 use turbopack_cli_utils::issue::{ConsoleUi, LogOptions};
 use turbopack_core::{
@@ -50,8 +52,10 @@ use crate::{
 
 pub(crate) mod web_entry_source;
 
+type Backend = TurboTasksBackend<NoopBackingStorage>;
+
 pub struct TurbopackDevServerBuilder {
-    turbo_tasks: Arc<TurboTasks<MemoryBackend>>,
+    turbo_tasks: Arc<TurboTasks<Backend>>,
     project_dir: RcStr,
     root_dir: RcStr,
     entry_requests: Vec<EntryRequest>,
@@ -68,7 +72,7 @@ pub struct TurbopackDevServerBuilder {
 
 impl TurbopackDevServerBuilder {
     pub fn new(
-        turbo_tasks: Arc<TurboTasks<MemoryBackend>>,
+        turbo_tasks: Arc<TurboTasks<Backend>>,
         project_dir: RcStr,
         root_dir: RcStr,
     ) -> TurbopackDevServerBuilder {
@@ -356,10 +360,12 @@ pub async fn start_server(args: &DevArguments) -> Result<()> {
         root_dir,
     } = normalize_dirs(&args.common.dir, &args.common.root)?;
 
-    let tt = TurboTasks::new(MemoryBackend::new(
-        args.common
-            .memory_limit
-            .map_or(usize::MAX, |l| l * 1024 * 1024),
+    let tt = TurboTasks::new(TurboTasksBackend::new(
+        BackendOptions {
+            storage_mode: None,
+            ..Default::default()
+        },
+        noop_backing_storage(),
     ));
 
     let tt_clone = tt.clone();
@@ -503,7 +509,7 @@ pub async fn start_server(args: &DevArguments) -> Result<()> {
 #[cfg(feature = "profile")]
 // When profiling, exits the process when no new updates have been received for
 // a given timeout and there are no more tasks in progress.
-async fn profile_timeout<T>(tt: &TurboTasks<MemoryBackend>, future: impl Future<Output = T>) -> T {
+async fn profile_timeout<T>(tt: &TurboTasks<Backend>, future: impl Future<Output = T>) -> T {
     /// How long to wait in between updates before force-exiting the process
     /// during profiling.
     const PROFILE_EXIT_TIMEOUT: Duration = Duration::from_secs(5);
@@ -523,7 +529,7 @@ async fn profile_timeout<T>(tt: &TurboTasks<MemoryBackend>, future: impl Future<
 
 #[cfg(not(feature = "profile"))]
 fn profile_timeout<T>(
-    _tt: &TurboTasks<MemoryBackend>,
+    _tt: &TurboTasks<Backend>,
     future: impl Future<Output = T>,
 ) -> impl Future<Output = T> {
     future

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

@@ -2,15 +2,12 @@ use std::{env::current_dir, path::PathBuf};
 
 use anyhow::{Context, Result};
 use dunce::canonicalize;
+use serde::{Deserialize, Serialize};
 use turbo_rcstr::RcStr;
-use turbo_tasks::{ResolvedVc, Vc};
+use turbo_tasks::{NonLocalValue, TaskInput, Vc};
 use turbo_tasks_fs::{DiskFileSystem, FileSystem};
 
-#[turbo_tasks::value(transparent)]
-pub struct EntryRequests(pub Vec<ResolvedVc<EntryRequest>>);
-
-#[turbo_tasks::value(shared)]
-#[derive(Clone)]
+#[derive(Clone, Debug, TaskInput, Hash, PartialEq, Eq, NonLocalValue, Serialize, Deserialize)]
 pub enum EntryRequest {
     Relative(RcStr),
     Module(RcStr, RcStr),