Conditionally track webpack loader dependencies based on whether or not we are tracking any dependencies

Author: lukesandberg

turbopack/crates/turbo-tasks-backend/src/backend/mod.rs

@@ -3104,6 +3104,10 @@ impl<B: BackingStorage> Backend for TurboTasksBackend<B> {
     fn task_statistics(&self) -> &TaskStatisticsApi {
         &self.0.task_statistics
     }
+
+    fn is_tracking_dependencies(&self) -> bool {
+        self.0.options.dependency_tracking
+    }
 }
 
 enum DebugTraceTransientTask {

turbopack/crates/turbo-tasks-testing/src/lib.rs

@@ -324,6 +324,10 @@ impl TurboTasksApi for VcStorage {
     fn send_compilation_event(&self, _event: Arc<dyn CompilationEvent>) {
         unimplemented!()
     }
+
+    fn is_tracking_dependencies(&self) -> bool {
+        false
+    }
 }
 
 impl VcStorage {

turbopack/crates/turbo-tasks/src/backend.rs

@@ -728,4 +728,6 @@ pub trait Backend: Sync + Send {
     fn dispose_root_task(&self, task: TaskId, turbo_tasks: &dyn TurboTasksBackendApi<Self>);
 
     fn task_statistics(&self) -> &TaskStatisticsApi;
+
+    fn is_tracking_dependencies(&self) -> bool;
 }

turbopack/crates/turbo-tasks/src/manager.rs

@@ -202,6 +202,9 @@ pub trait TurboTasksApi: TurboTasksCallApi + Sync + Send {
         event_types: Option<Vec<String>>,
     ) -> Receiver<Arc<dyn CompilationEvent>>;
     fn send_compilation_event(&self, event: Arc<dyn CompilationEvent>);
+
+    // Returns true if TurboTasks is configured to track dependencies.
+    fn is_tracking_dependencies(&self) -> bool;
 }
 
 /// A wrapper around a value that is unused.
@@ -1442,6 +1445,10 @@ impl<B: Backend + 'static> TurboTasksApi for TurboTasks<B> {
             tracing::warn!("Failed to send compilation event: {e}");
         }
     }
+
+    fn is_tracking_dependencies(&self) -> bool {
+        self.backend.is_tracking_dependencies()
+    }
 }
 
 impl<B: Backend + 'static> TurboTasksBackendApi<B> for TurboTasks<B> {

turbopack/crates/turbopack-node/src/transforms/webpack.rs

@@ -497,48 +497,53 @@ impl EvaluateContext for WebpackLoaderContext {
                 directories,
                 build_file_paths,
             } => {
-                // Track dependencies of the loader task
-                // TODO: Because these are reported _after_ the loader actually read the dependency
-                // there is a race condition where we may miss updates that race
-                // with the loader execution.
-
-                // Track all the subscriptions in parallel, since certain loaders like tailwind
-                // might add thousands of subscriptions.
-                let env_subscriptions = env_variables
-                    .iter()
-                    .map(|e| self.env.read(e.clone()))
-                    .try_join();
-                let file_subscriptions = file_paths
-                    .iter()
-                    .map(|p| async move { self.cwd.join(p)?.read().await })
-                    .try_join();
-                let directory_subscriptions = directories
-                    .iter()
-                    .map(|(dir, glob)| async move {
-                        self.cwd
-                            .join(dir)?
-                            .track_glob(Glob::new(glob.clone(), GlobOptions::default()), false)
-                            .await
-                    })
-                    .try_join();
-                let build_paths = build_file_paths
-                    .iter()
-                    .map(|path| async move { self.cwd.join(path) })
-                    .try_join();
-                let (resolved_build_paths, ..) = try_join!(
-                    build_paths,
-                    env_subscriptions,
-                    file_subscriptions,
-                    directory_subscriptions
-                )?;
-
-                for build_path in resolved_build_paths {
-                    BuildDependencyIssue {
-                        source: IssueSource::from_source_only(self.context_source_for_issue),
-                        path: build_path,
+                // We only process these dependencies to help with tracking, so if it is disabled
+                // dont bother.
+                if turbo_tasks::turbo_tasks().is_tracking_dependencies() {
+                    // Track dependencies of the loader task
+                    // TODO: Because these are reported _after_ the loader actually read the
+                    // dependency there is a race condition where we may miss
+                    // updates that race with the loader execution.
+
+                    // Track all the subscriptions in parallel, since certain loaders like tailwind
+                    // might add thousands of subscriptions.
+                    let env_subscriptions = env_variables
+                        .iter()
+                        .map(|e| self.env.read(e.clone()))
+                        .try_join();
+                    let file_subscriptions = file_paths
+                        .iter()
+                        .map(|p| async move { self.cwd.join(p)?.read().await })
+                        .try_join();
+                    let directory_subscriptions = directories
+                        .iter()
+                        .map(|(dir, glob)| async move {
+                            self.cwd
+                                .join(dir)?
+                                .track_glob(Glob::new(glob.clone(), GlobOptions::default()), false)
+                                .await
+                        })
+                        .try_join();
+                    let build_paths = build_file_paths
+                        .iter()
+                        .map(|path| async move { self.cwd.join(path) })
+                        .try_join();
+                    let (resolved_build_paths, ..) = try_join!(
+                        build_paths,
+                        env_subscriptions,
+                        file_subscriptions,
+                        directory_subscriptions
+                    )?;
+
+                    // These are 'build-dependency' messages from PostCss.
+                    for build_path in resolved_build_paths {
+                        BuildDependencyIssue {
+                            source: IssueSource::from_source_only(self.context_source_for_issue),
+                            path: build_path,
+                        }
+                        .resolved_cell()
+                        .emit();
                     }
-                    .resolved_cell()
-                    .emit();
                 }
             }
             InfoMessage::EmittedError { error, severity } => {