[turbopack] Simplify JS ChunkItem with a single impl in most cases (#89548)

# What

Removes the vast majority of `ChunkItem` implementations in favour of
one `EcmascriptModuleChunkItem`.

# Why

Almost all of the `ChunkItem` implementations are trivial and were, for
the most part, just places where additional traits could be implemented.

By removing all of the various, trivial implementations, this might open
up opportunities to better implement other features across the entire
codebase.

# How

Most chunk items are migrated over to EcmascriptModuleChunkItem. The
EcmascriptChunkPlaceable trait gains three new methods that modules can
optionally override:

  -  `chunk_item_content()` - generates the chunk item's JavaScript code
- `chunk_item_content_ident()` - returns the content identity for cache
invalidation
- `chunk_item_output_assets()` - returns output assets the chunk item
depends on

The generic EcmascriptModuleChunkItem delegates to these trait methods,
eliminating the need for per-module wrapper structs.

Author: mmastrac

crates/next-core/src/hmr_entry.rs

@@ -7,21 +7,20 @@ use turbo_tasks_fs::{FileSystem, VirtualFileSystem, rope::RopeBuilder};
 use turbopack_core::{
     asset::{Asset, AssetContent},
     chunk::{
-        ChunkItem, ChunkType, ChunkableModule, ChunkingContext, ChunkingType, ChunkingTypeOption,
-        EvaluatableAsset,
+        AsyncModuleInfo, ChunkItem, ChunkableModule, ChunkingContext, ChunkingType,
+        ChunkingTypeOption, EvaluatableAsset,
     },
     ident::AssetIdent,
     module::{Module, ModuleSideEffects},
     module_graph::ModuleGraph,
-    output::OutputAssetsReference,
     reference::{ModuleReference, ModuleReferences},
     resolve::ModuleResolveResult,
     source::OptionSource,
 };
 use turbopack_ecmascript::{
     chunk::{
-        EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkItemOptions,
-        EcmascriptChunkPlaceable, EcmascriptChunkType, EcmascriptExports,
+        EcmascriptChunkItemContent, EcmascriptChunkItemOptions, EcmascriptChunkPlaceable,
+        EcmascriptExports, ecmascript_chunk_item,
     },
     runtime_functions::TURBOPACK_REQUIRE,
     utils::StringifyJs,
@@ -90,14 +89,7 @@ impl ChunkableModule for HmrEntryModule {
         module_graph: ResolvedVc<ModuleGraph>,
         chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
     ) -> Vc<Box<dyn ChunkItem>> {
-        Vc::upcast(
-            HmrEntryChunkItem {
-                module: self,
-                module_graph,
-                chunking_context,
-            }
-            .cell(),
-        )
+        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
     }
 }
 
@@ -115,6 +107,36 @@ impl EcmascriptChunkPlaceable for HmrEntryModule {
     fn get_exports(self: Vc<Self>) -> Vc<EcmascriptExports> {
         EcmascriptExports::None.cell()
     }
+
+    #[turbo_tasks::function]
+    async fn chunk_item_content(
+        self: Vc<Self>,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
+        module_graph: Vc<ModuleGraph>,
+        _async_module_info: Option<Vc<AsyncModuleInfo>>,
+        _estimated: bool,
+    ) -> Result<Vc<EcmascriptChunkItemContent>> {
+        let this = self.await?;
+        let module = this.module;
+        let chunk_item = module.as_chunk_item(module_graph, chunking_context);
+        let id = chunking_context
+            .chunk_item_id_strategy()
+            .await?
+            .get_id(chunk_item)
+            .await?;
+
+        let mut code = RopeBuilder::default();
+        writeln!(code, "{TURBOPACK_REQUIRE}({});", StringifyJs(&id))?;
+        Ok(EcmascriptChunkItemContent {
+            inner_code: code.build(),
+            options: EcmascriptChunkItemOptions {
+                strict: true,
+                ..Default::default()
+            },
+            ..Default::default()
+        }
+        .cell())
+    }
 }
 
 #[turbo_tasks::value_impl]
@@ -149,72 +171,10 @@ impl ModuleReference for HmrEntryModuleReference {
     }
 
     #[turbo_tasks::function]
-    fn chunking_type(self: Vc<Self>) -> Vc<ChunkingTypeOption> {
+    fn chunking_type(&self) -> Vc<ChunkingTypeOption> {
         Vc::cell(Some(ChunkingType::Parallel {
             inherit_async: false,
             hoisted: false,
         }))
     }
 }
-
-/// The chunk item for [`HmrEntryModule`].
-#[turbo_tasks::value]
-struct HmrEntryChunkItem {
-    module: ResolvedVc<HmrEntryModule>,
-    module_graph: ResolvedVc<ModuleGraph>,
-    chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-}
-
-#[turbo_tasks::value_impl]
-impl OutputAssetsReference for HmrEntryChunkItem {}
-
-#[turbo_tasks::value_impl]
-impl ChunkItem for HmrEntryChunkItem {
-    #[turbo_tasks::function]
-    fn chunking_context(&self) -> Vc<Box<dyn ChunkingContext>> {
-        *self.chunking_context
-    }
-
-    #[turbo_tasks::function]
-    fn asset_ident(&self) -> Vc<AssetIdent> {
-        self.module.ident()
-    }
-
-    #[turbo_tasks::function]
-    fn ty(&self) -> Vc<Box<dyn ChunkType>> {
-        Vc::upcast(Vc::<EcmascriptChunkType>::default())
-    }
-
-    #[turbo_tasks::function]
-    fn module(&self) -> Vc<Box<dyn Module>> {
-        Vc::upcast(*self.module)
-    }
-}
-
-#[turbo_tasks::value_impl]
-impl EcmascriptChunkItem for HmrEntryChunkItem {
-    #[turbo_tasks::function]
-    async fn content(&self) -> Result<Vc<EcmascriptChunkItemContent>> {
-        let this = self.module.await?;
-        let module = this.module;
-        let chunk_item = module.as_chunk_item(*self.module_graph, *self.chunking_context);
-        let id = self
-            .chunking_context
-            .chunk_item_id_strategy()
-            .await?
-            .get_id(chunk_item)
-            .await?;
-
-        let mut code = RopeBuilder::default();
-        writeln!(code, "{TURBOPACK_REQUIRE}({});", StringifyJs(&id))?;
-        Ok(EcmascriptChunkItemContent {
-            inner_code: code.build(),
-            options: EcmascriptChunkItemOptions {
-                strict: true,
-                ..Default::default()
-            },
-            ..Default::default()
-        }
-        .cell())
-    }
-}

crates/next-core/src/next_client_reference/ecmascript_client_reference/ecmascript_client_reference_module.rs

@@ -281,6 +281,17 @@ impl EcmascriptChunkPlaceable for EcmascriptClientReferenceModule {
     fn get_exports(self: Vc<Self>) -> Vc<EcmascriptExports> {
         self.proxy_module().get_exports()
     }
+
+    #[turbo_tasks::function]
+    fn chunk_item_content(
+        self: Vc<Self>,
+        _chunking_context: Vc<Box<dyn ChunkingContext>>,
+        _module_graph: Vc<ModuleGraph>,
+        _async_module_info: Option<Vc<AsyncModuleInfo>>,
+        _estimated: bool,
+    ) -> Result<Vc<EcmascriptChunkItemContent>> {
+        bail!("Attempted to get chunk_item_content for EcmascriptClientReferenceModule")
+    }
 }
 
 /// This wrapper only exists to overwrite the `asset_ident` method of the

crates/next-core/src/next_dynamic/dynamic_module.rs

@@ -5,19 +5,18 @@ use indoc::formatdoc;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{ResolvedVc, Vc};
 use turbopack_core::{
-    chunk::{ChunkItem, ChunkType, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
+    chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
     ident::AssetIdent,
     module::{Module, ModuleSideEffects},
     module_graph::ModuleGraph,
-    output::OutputAssetsReference,
     reference::{ModuleReferences, SingleChunkableModuleReference},
     resolve::ExportUsage,
     source::OptionSource,
 };
 use turbopack_ecmascript::{
     chunk::{
-        EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
-        EcmascriptChunkType, EcmascriptExports,
+        EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports,
+        ecmascript_chunk_item,
     },
     references::esm::{EsmExport, EsmExports},
     runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
@@ -84,14 +83,7 @@ impl ChunkableModule for NextDynamicEntryModule {
         module_graph: ResolvedVc<ModuleGraph>,
         chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
     ) -> Vc<Box<dyn turbopack_core::chunk::ChunkItem>> {
-        Vc::upcast(
-            NextDynamicEntryChunkItem {
-                chunking_context,
-                module_graph,
-                inner: self,
-            }
-            .cell(),
-        )
+        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
     }
 }
 
@@ -125,25 +117,16 @@ impl EcmascriptChunkPlaceable for NextDynamicEntryModule {
         )
         .cell())
     }
-}
-
-#[turbo_tasks::value]
-struct NextDynamicEntryChunkItem {
-    chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    module_graph: ResolvedVc<ModuleGraph>,
-    inner: ResolvedVc<NextDynamicEntryModule>,
-}
-
-#[turbo_tasks::value_impl]
-impl OutputAssetsReference for NextDynamicEntryChunkItem {}
 
-#[turbo_tasks::value_impl]
-impl EcmascriptChunkItem for NextDynamicEntryChunkItem {
     #[turbo_tasks::function]
-    async fn content(&self) -> Result<Vc<EcmascriptChunkItemContent>> {
-        let inner = self.inner.await?;
-
-        let module_id = inner.module.chunk_item_id(*self.chunking_context).await?;
+    async fn chunk_item_content(
+        &self,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
+        _module_graph: Vc<ModuleGraph>,
+        _async_module_info: Option<Vc<AsyncModuleInfo>>,
+        _estimated: bool,
+    ) -> Result<Vc<EcmascriptChunkItemContent>> {
+        let module_id = self.module.chunk_item_id(chunking_context).await?;
         Ok(EcmascriptChunkItemContent {
             inner_code: formatdoc!(
                 r#"
@@ -157,26 +140,3 @@ impl EcmascriptChunkItem for NextDynamicEntryChunkItem {
         .cell())
     }
 }
-
-#[turbo_tasks::value_impl]
-impl ChunkItem for NextDynamicEntryChunkItem {
-    #[turbo_tasks::function]
-    fn asset_ident(&self) -> Vc<AssetIdent> {
-        self.inner.ident()
-    }
-
-    #[turbo_tasks::function]
-    fn chunking_context(&self) -> Vc<Box<dyn ChunkingContext>> {
-        *self.chunking_context
-    }
-
-    #[turbo_tasks::function]
-    fn ty(&self) -> Vc<Box<dyn ChunkType>> {
-        Vc::upcast(Vc::<EcmascriptChunkType>::default())
-    }
-
-    #[turbo_tasks::function]
-    fn module(&self) -> Vc<Box<dyn Module>> {
-        Vc::upcast(*self.inner)
-    }
-}

crates/next-core/src/next_server_component/server_component_module.rs

@@ -6,18 +6,17 @@ use turbo_rcstr::rcstr;
 use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::{
-    chunk::{ChunkItem, ChunkType, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
+    chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
     ident::AssetIdent,
     module::{Module, ModuleSideEffects},
     module_graph::ModuleGraph,
-    output::OutputAssetsReference,
     reference::ModuleReferences,
     source::OptionSource,
 };
 use turbopack_ecmascript::{
     chunk::{
-        EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
-        EcmascriptChunkType, EcmascriptExports,
+        EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports,
+        ecmascript_chunk_item,
     },
     references::esm::{EsmExport, EsmExports},
     runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
@@ -101,14 +100,7 @@ impl ChunkableModule for NextServerComponentModule {
         module_graph: ResolvedVc<ModuleGraph>,
         chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
     ) -> Vc<Box<dyn turbopack_core::chunk::ChunkItem>> {
-        Vc::upcast(
-            NextServerComponentChunkItem {
-                module_graph,
-                chunking_context,
-                inner: self,
-            }
-            .cell(),
-        )
+        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
     }
 }
 
@@ -138,25 +130,16 @@ impl EcmascriptChunkPlaceable for NextServerComponentModule {
         )
         .cell())
     }
-}
-
-#[turbo_tasks::value]
-struct NextServerComponentChunkItem {
-    module_graph: ResolvedVc<ModuleGraph>,
-    chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    inner: ResolvedVc<NextServerComponentModule>,
-}
-
-#[turbo_tasks::value_impl]
-impl OutputAssetsReference for NextServerComponentChunkItem {}
 
-#[turbo_tasks::value_impl]
-impl EcmascriptChunkItem for NextServerComponentChunkItem {
     #[turbo_tasks::function]
-    async fn content(&self) -> Result<Vc<EcmascriptChunkItemContent>> {
-        let inner = self.inner.await?;
-
-        let module_id = inner.module.chunk_item_id(*self.chunking_context).await?;
+    async fn chunk_item_content(
+        &self,
+        chunking_context: Vc<Box<dyn ChunkingContext>>,
+        _module_graph: Vc<ModuleGraph>,
+        _async_module_info: Option<Vc<AsyncModuleInfo>>,
+        _estimated: bool,
+    ) -> Result<Vc<EcmascriptChunkItemContent>> {
+        let module_id = self.module.chunk_item_id(chunking_context).await?;
         Ok(EcmascriptChunkItemContent {
             inner_code: formatdoc!(
                 r#"
@@ -170,26 +153,3 @@ impl EcmascriptChunkItem for NextServerComponentChunkItem {
         .cell())
     }
 }
-
-#[turbo_tasks::value_impl]
-impl ChunkItem for NextServerComponentChunkItem {
-    #[turbo_tasks::function]
-    fn asset_ident(&self) -> Vc<AssetIdent> {
-        self.inner.ident()
-    }
-
-    #[turbo_tasks::function]
-    fn chunking_context(&self) -> Vc<Box<dyn ChunkingContext>> {
-        *self.chunking_context
-    }
-
-    #[turbo_tasks::function]
-    fn ty(&self) -> Vc<Box<dyn ChunkType>> {
-        Vc::upcast(Vc::<EcmascriptChunkType>::default())
-    }
-
-    #[turbo_tasks::function]
-    fn module(&self) -> Vc<Box<dyn Module>> {
-        Vc::upcast(*self.inner)
-    }
-}