[turbopack] Remove the turbo_tasks::function attributes from a number of tasks that do not get cache hits. (#83241)

Drop `turbo_tasks::function` annotation from functions that never get cache hits.

We only do this in cases where:
* there are no cache hits in production or dev builds
* There is a structural reason for it.  Typically, because that task is 'dominated' by another one.
* Or, the task being cached is so small that we shouldn't worry about even theoretical hits.

Tasks being modified or removed (numbers are from a vercel-site build):
* `turbopack-ecmascript::parse::parse`  (63398 tasks)
    - this task gets no hits due to a few 'dominating' tasks. In this case we remove turbotasks::function from `EcmascriptModuleAsset::parse`, since there are some theoretical hits.
* `EcmascriptChunkItemContent::module_factory` (55804 tasks)
    - This function is completely 'dominated' by `module_factory_with_code_generation_issue` so we don't need it, even in a PC environment we should expect this to be the case
* `Module::style_type` (63237 tasks, though we don't save all of them)
    * Only gets called once for each module so there were no cache hits.  However, it is useful for HMR and PC to ensure we don't recompute style groups. So move this to a new trait and call it conditionally which eliminates all overhead while preseving cacheability
*  `track_glob` (11432 tasks)
     * this is used to set up dependencies on files read by webpack loaders.  This was made conditional on whether or not any dependencies are being tracked. at all
* `apply_module_type` (152887 tasks) and `apply_reexport_treeshaking` (57527 tasks):
    - both of these are dominated by other tasks
* `EcmascriptAnalyzable::module_content` (40310 tasks)
    - This one is trivially dominated and really just plugs two other Vcs together, so i dropped `turbo_tasks::function`, as default trait method this actually required a new feature in the macro gencode.

So altogether this eliminates about 4.97% (444595/8939581)  tasks from a build of vercel-site. 

From measuring the builds I also see a progression

![image.png](https://app.graphite.dev/user-attachments/assets/f7d960e1-30d6-4430-8712-ae94723adaae.png)

Which is  (@p50) 1.7 seconds faster (-2.6%) and uses 290 MB less memory (-2%).  The micro benchmarks show bigger progressions, but that makes sense, they are more sensitive to overheads.

Author: lukesandberg

crates/napi/src/next_api/project.rs

@@ -438,8 +438,7 @@ pub fn project_new(
         )?;
         let turbopack_ctx = NextTurbopackContext::new(turbo_tasks.clone(), napi_callbacks);
 
-        let stats_path = std::env::var_os("NEXT_TURBOPACK_TASK_STATISTICS");
-        if let Some(stats_path) = stats_path {
+        if let Some(stats_path) = std::env::var_os("NEXT_TURBOPACK_TASK_STATISTICS") {
             let task_stats = turbo_tasks.task_statistics().enable().clone();
             exit.on_exit(async move {
                 tokio::task::spawn_blocking(move || {

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

@@ -3077,6 +3077,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

@@ -726,4 +726,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/turbo-tasks/src/vc/resolved.rs

@@ -243,7 +243,7 @@ where
     /// Returns `None` if the underlying value type does not implement `K`.
     ///
     /// **Note:** if the trait `T` is required to implement `K`, use [`ResolvedVc::upcast`] instead.
-    /// This provides stronger guarantees, removing the need for a [`Result`] return type.
+    /// This provides stronger guarantees, removing the need for a [`Option`] return type.
     ///
     /// See also: [`Vc::try_resolve_sidecast`].
     pub fn try_sidecast<K>(this: Self) -> Option<ResolvedVc<K>>

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

@@ -1,17 +1,14 @@
-use serde::{Deserialize, Serialize};
-use turbo_tasks::{NonLocalValue, ResolvedVc, Vc, trace::TraceRawVcs};
+use turbo_tasks::{ResolvedVc, TaskInput, Vc};
 
 use crate::{asset::Asset, ident::AssetIdent, reference::ModuleReferences};
 
-#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, TraceRawVcs, NonLocalValue)]
+#[derive(Clone, Copy, Debug, TaskInput, Hash)]
+#[turbo_tasks::value(shared)]
 pub enum StyleType {
     IsolatedStyle,
     GlobalStyle,
 }
 
-#[turbo_tasks::value(transparent)]
-pub struct OptionStyleType(Option<StyleType>);
-
 /// A module. This usually represents parsed source code, which has references
 /// to other modules.
 #[turbo_tasks::value_trait]
@@ -33,12 +30,13 @@ pub trait Module: Asset {
     fn is_self_async(self: Vc<Self>) -> Vc<bool> {
         Vc::cell(false)
     }
+}
 
+#[turbo_tasks::value_trait]
+pub trait StyleModule: Module + Asset {
     /// The style type of the module.
     #[turbo_tasks::function]
-    fn style_type(self: Vc<Self>) -> Vc<OptionStyleType> {
-        Vc::cell(None)
-    }
+    fn style_type(&self) -> Vc<StyleType>;
 }
 
 #[turbo_tasks::value(transparent)]

turbopack/crates/turbopack-core/src/module_graph/style_groups.rs

@@ -15,7 +15,7 @@ use crate::{
         ChunkItem, ChunkItemBatchWithAsyncModuleInfo, ChunkItemWithAsyncModuleInfo, ChunkType,
         ChunkableModule, ChunkingContext, chunk_item_batch::attach_async_info_to_chunkable_module,
     },
-    module::{Module, StyleType},
+    module::{Module, StyleModule, StyleType},
     module_graph::{
         GraphTraversalAction, ModuleGraph, module_batch::ModuleOrBatch,
         module_batches::ModuleBatchesGraphEdge,
@@ -129,8 +129,10 @@ pub async fn compute_style_groups(
                     }
                 }
                 Entry::Vacant(e) => {
-                    let style_type = *module.style_type().await?;
-                    if let Some(style_type) = style_type {
+                    if let Some(style_module) =
+                        ResolvedVc::try_sidecast::<Box<dyn StyleModule>>(module)
+                    {
+                        let style_type = *style_module.style_type().await?;
                         let mut info =
                             ModuleInfo::new(style_type, module.ident().to_string().owned().await?);
                         info.chunk_group_indices.insert(idx, styles.len());

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

@@ -8,7 +8,7 @@ use turbopack_core::{
     context::AssetContext,
     environment::Environment,
     ident::AssetIdent,
-    module::{Module, OptionStyleType, StyleType},
+    module::{Module, StyleModule, StyleType},
     module_graph::ModuleGraph,
     output::OutputAssets,
     reference::{ModuleReference, ModuleReferences},
@@ -148,14 +148,16 @@ impl Module for CssModuleAsset {
             ParseCssResult::NotFound => Ok(ModuleReferences::empty()),
         }
     }
+}
 
+#[turbo_tasks::value_impl]
+impl StyleModule for CssModuleAsset {
     #[turbo_tasks::function]
-    fn style_type(&self) -> Vc<OptionStyleType> {
-        let style_type = match self.ty {
-            CssModuleAssetType::Default => StyleType::GlobalStyle,
-            CssModuleAssetType::Module => StyleType::IsolatedStyle,
-        };
-        Vc::cell(Some(style_type))
+    fn style_type(&self) -> Vc<StyleType> {
+        match self.ty {
+            CssModuleAssetType::Default => StyleType::GlobalStyle.cell(),
+            CssModuleAssetType::Module => StyleType::IsolatedStyle.cell(),
+        }
     }
 }
 

turbopack/crates/turbopack-ecmascript/src/chunk/item.rs

@@ -85,9 +85,10 @@ impl EcmascriptChunkItemContent {
         }
         .cell())
     }
+}
 
-    #[turbo_tasks::function]
-    pub async fn module_factory(&self) -> Result<Vc<Code>> {
+impl EcmascriptChunkItemContent {
+    async fn module_factory(&self) -> Result<ResolvedVc<Code>> {
         let mut code = CodeBuilder::default();
         for additional_id in self.additional_ids.iter().try_join().await? {
             writeln!(code, "{}, ", StringifyJs(&*additional_id))?;
@@ -130,7 +131,7 @@ impl EcmascriptChunkItemContent {
 
         code += "})";
 
-        Ok(code.build().cell())
+        Ok(code.build().resolved_cell())
     }
 }
 
@@ -221,37 +222,37 @@ async fn module_factory_with_code_generation_issue(
     chunk_item: Vc<Box<dyn EcmascriptChunkItem>>,
     async_module_info: Option<Vc<AsyncModuleInfo>>,
 ) -> Result<Vc<Code>> {
-    Ok(
-        match chunk_item
-            .content_with_async_module_info(async_module_info)
-            .module_factory()
-            .resolve()
-            .await
-        {
-            Ok(factory) => factory,
-            Err(error) => {
-                let id = chunk_item.asset_ident().to_string().await;
-                let id = id.as_ref().map_or_else(|_| "unknown", |id| &**id);
-                let error = error.context(format!(
-                    "An error occurred while generating the chunk item {id}"
-                ));
-                let error_message = format!("{}", PrettyPrintError(&error)).into();
-                let js_error_message = serde_json::to_string(&error_message)?;
-                CodeGenerationIssue {
-                    severity: IssueSeverity::Error,
-                    path: chunk_item.asset_ident().path().owned().await?,
-                    title: StyledString::Text(rcstr!("Code generation for chunk item errored"))
-                        .resolved_cell(),
-                    message: StyledString::Text(error_message).resolved_cell(),
-                }
-                .resolved_cell()
-                .emit();
-                let mut code = CodeBuilder::default();
-                code += "(() => {{\n\n";
-                writeln!(code, "throw new Error({error});", error = &js_error_message)?;
-                code += "\n}})";
-                code.build().cell()
+    let content = match chunk_item
+        .content_with_async_module_info(async_module_info)
+        .await
+    {
+        Ok(item) => item.module_factory().await,
+        Err(err) => Err(err),
+    };
+    Ok(match content {
+        Ok(factory) => *factory,
+        Err(error) => {
+            let id = chunk_item.asset_ident().to_string().await;
+            let id = id.as_ref().map_or_else(|_| "unknown", |id| &**id);
+            let error = error.context(format!(
+                "An error occurred while generating the chunk item {id}"
+            ));
+            let error_message = format!("{}", PrettyPrintError(&error)).into();
+            let js_error_message = serde_json::to_string(&error_message)?;
+            CodeGenerationIssue {
+                severity: IssueSeverity::Error,
+                path: chunk_item.asset_ident().path().owned().await?,
+                title: StyledString::Text(rcstr!("Code generation for chunk item errored"))
+                    .resolved_cell(),
+                message: StyledString::Text(error_message).resolved_cell(),
             }
-        },
-    )
+            .resolved_cell()
+            .emit();
+            let mut code = CodeBuilder::default();
+            code += "(() => {{\n\n";
+            writeln!(code, "throw new Error({error});", error = &js_error_message)?;
+            code += "\n}})";
+            code.build().cell()
+        }
+    })
 }