Remove ChunkingModule

Author: mmastrac

crates/next-api/src/dynamic_imports.rs

@@ -30,7 +30,7 @@ use turbo_tasks::{
     debug::ValueDebugFormat, trace::TraceRawVcs,
 };
 use turbopack_core::{
-    chunk::{ChunkableModule, ChunkingContext, availability_info::AvailabilityInfo},
+    chunk::{ChunkingContext, availability_info::AvailabilityInfo},
     module::Module,
     module_graph::{ModuleGraph, ModuleGraphLayer},
     output::{OutputAssetsReference, OutputAssetsWithReferenced},
@@ -55,7 +55,7 @@ pub(crate) async fn collect_next_dynamic_chunks(
     let dynamic_import_chunks = dynamic_import_entries
         .iter()
         .map(|(dynamic_entry, parent_client_reference)| async move {
-            let module = ResolvedVc::upcast::<Box<dyn ChunkableModule>>(*dynamic_entry);
+            let module = ResolvedVc::upcast::<Box<dyn Module>>(*dynamic_entry);
 
             // This is the availability info for the parent chunk group, i.e. the client reference
             // containing the next/dynamic imports

crates/next-api/src/pages.rs

@@ -44,8 +44,8 @@ use turbopack::{
 use turbopack_core::{
     asset::AssetContent,
     chunk::{
-        ChunkGroupResult, ChunkingContext, ChunkingContextExt, EvaluatableAsset, EvaluatableAssets,
-        availability_info::AvailabilityInfo,
+        ChunkGroupResult, ChunkType, ChunkingContext, ChunkingContextExt, EvaluatableAsset,
+        EvaluatableAssets, availability_info::AvailabilityInfo,
     },
     context::AssetContext,
     file_source::FileSource,
@@ -658,14 +658,32 @@ impl PageEndpoint {
             self.source(),
             this.pathname.clone(),
         );
+        let is_chunkable = {
+            let page_loader_resolved = page_loader.to_resolved().await?;
+            let configs = this
+                .pages_project
+                .project()
+                .client_chunking_context()
+                .chunking_configs()
+                .await?;
+            let mut chunkable = false;
+            for (chunk_type, _) in configs.iter() {
+                if *chunk_type.accepts_module(*page_loader_resolved).await? {
+                    chunkable = true;
+                    break;
+                }
+            }
+            chunkable
+        };
         if matches!(
             *this.pages_project.project().next_mode().await?,
             NextMode::Development
-        ) && let Some(chunkable) = ResolvedVc::try_downcast(page_loader.to_resolved().await?)
+        ) && is_chunkable
         {
+            let module = page_loader.to_resolved().await?;
             return Ok(Vc::upcast(HmrEntryModule::new(
                 AssetIdent::from_path(this.page.await?.base_path.clone()),
-                *chunkable,
+                *module,
             )));
         }
         Ok(page_loader)

crates/next-api/src/server_actions.rs

@@ -26,9 +26,7 @@ use turbo_tasks::{
 use turbo_tasks_fs::{self, File, FileContent, FileSystemPath, rope::RopeBuilder};
 use turbopack_core::{
     asset::AssetContent,
-    chunk::{
-        ChunkItem, ChunkItemExt, ChunkableModule, ChunkingContext, EvaluatableAsset, ModuleId,
-    },
+    chunk::{ChunkItem, ChunkItemExt, ChunkingContext, EvaluatableAsset, ModuleId},
     context::AssetContext,
     file_source::FileSource,
     ident::AssetIdent,
@@ -78,7 +76,7 @@ pub(crate) async fn create_server_actions_manifest(
         ResolvedVc::try_sidecast::<Box<dyn EvaluatableAsset>>(loader.to_resolved().await?)
             .context("loader module must be evaluatable")?;
 
-    let chunk_item = loader.as_chunk_item(module_graph, chunking_context);
+    let chunk_item = ChunkItem::new(Vc::upcast(loader), module_graph, chunking_context);
     let manifest = build_manifest(
         node_root,
         page_name,
@@ -158,7 +156,7 @@ async fn build_manifest(
     page_name: RcStr,
     runtime: NextRuntime,
     actions: Vc<AllActions>,
-    chunk_item: Vc<Box<dyn ChunkItem>>,
+    chunk_item: Vc<ChunkItem>,
     async_module_info: Vc<AsyncModulesInfo>,
 ) -> Result<ResolvedVc<Box<dyn OutputAsset>>> {
     let manifest_path_prefix = &page_name;

crates/next-api/src/webpack_stats.rs

@@ -25,8 +25,7 @@ where
 {
     let mut assets = vec![];
     let mut chunks = vec![];
-    let mut chunk_items: FxIndexMap<Vc<Box<dyn ChunkItem>>, FxIndexSet<RcStr>> =
-        FxIndexMap::default();
+    let mut chunk_items: FxIndexMap<Vc<ChunkItem>, FxIndexSet<RcStr>> = FxIndexMap::default();
 
     let entry_assets = entry_assets.into_iter().collect::<Vec<_>>();
 

crates/next-core/src/hmr_entry.rs

@@ -7,8 +7,8 @@ use turbo_tasks_fs::{FileSystem, VirtualFileSystem, rope::RopeBuilder};
 use turbopack_core::{
     asset::{Asset, AssetContent},
     chunk::{
-        AsyncModuleInfo, ChunkItem, ChunkableModule, ChunkingContext, ChunkingType,
-        ChunkingTypeOption, EvaluatableAsset,
+        AsyncModuleInfo, ChunkItem, ChunkingContext, ChunkingType, ChunkingTypeOption,
+        EvaluatableAsset,
     },
     ident::AssetIdent,
     module::{Module, ModuleSideEffects},
@@ -20,7 +20,7 @@ use turbopack_core::{
 use turbopack_ecmascript::{
     chunk::{
         EcmascriptChunkItemContent, EcmascriptChunkItemOptions, EcmascriptChunkPlaceable,
-        EcmascriptExports, ecmascript_chunk_item,
+        EcmascriptExports,
     },
     runtime_functions::TURBOPACK_REQUIRE,
     utils::StringifyJs,
@@ -41,16 +41,13 @@ async fn hmr_entry_point_base_ident() -> Result<Vc<AssetIdent>> {
 #[turbo_tasks::value(shared)]
 pub struct HmrEntryModule {
     pub ident: ResolvedVc<AssetIdent>,
-    pub module: ResolvedVc<Box<dyn ChunkableModule>>,
+    pub module: ResolvedVc<Box<dyn Module>>,
 }
 
 #[turbo_tasks::value_impl]
 impl HmrEntryModule {
     #[turbo_tasks::function]
-    pub fn new(
-        ident: ResolvedVc<AssetIdent>,
-        module: ResolvedVc<Box<dyn ChunkableModule>>,
-    ) -> Vc<Self> {
+    pub fn new(ident: ResolvedVc<AssetIdent>, module: ResolvedVc<Box<dyn Module>>) -> Vc<Self> {
         Self { ident, module }.cell()
     }
 }
@@ -70,7 +67,7 @@ impl Module for HmrEntryModule {
     #[turbo_tasks::function]
     async fn references(&self) -> Result<Vc<ModuleReferences>> {
         Ok(Vc::cell(vec![ResolvedVc::upcast(
-            HmrEntryModuleReference::new(Vc::upcast(*self.module))
+            HmrEntryModuleReference::new(*self.module)
                 .to_resolved()
                 .await?,
         )]))
@@ -81,18 +78,6 @@ impl Module for HmrEntryModule {
     }
 }
 
-#[turbo_tasks::value_impl]
-impl ChunkableModule for HmrEntryModule {
-    #[turbo_tasks::function]
-    fn as_chunk_item(
-        self: ResolvedVc<Self>,
-        module_graph: ResolvedVc<ModuleGraph>,
-        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    ) -> Vc<Box<dyn ChunkItem>> {
-        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
-    }
-}
-
 #[turbo_tasks::value_impl]
 impl Asset for HmrEntryModule {
     #[turbo_tasks::function]
@@ -118,7 +103,7 @@ impl EcmascriptChunkPlaceable for HmrEntryModule {
     ) -> Result<Vc<EcmascriptChunkItemContent>> {
         let this = self.await?;
         let module = this.module;
-        let chunk_item = module.as_chunk_item(module_graph, chunking_context);
+        let chunk_item = ChunkItem::new(*module, module_graph, chunking_context);
         let id = chunking_context
             .chunk_item_id_strategy()
             .await?

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

@@ -7,10 +7,7 @@ use turbo_tasks::{IntoTraitRef, ResolvedVc, ValueToString, Vc};
 use turbo_tasks_fs::{File, FileContent};
 use turbopack_core::{
     asset::AssetContent,
-    chunk::{
-        AsyncModuleInfo, ChunkGroupType, ChunkItem, ChunkableModule, ChunkingContext, ChunkingType,
-        ChunkingTypeOption,
-    },
+    chunk::{AsyncModuleInfo, ChunkGroupType, ChunkingContext, ChunkingType, ChunkingTypeOption},
     code_builder::CodeBuilder,
     context::AssetContext,
     ident::AssetIdent,
@@ -23,10 +20,7 @@ use turbopack_core::{
     virtual_source::VirtualSource,
 };
 use turbopack_ecmascript::{
-    chunk::{
-        EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports,
-        ecmascript_chunk_item,
-    },
+    chunk::{EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports},
     runtime_functions::TURBOPACK_EXPORT_NAMESPACE,
     utils::StringifyJs,
 };
@@ -248,22 +242,6 @@ impl Module for EcmascriptClientReferenceModule {
     }
 }
 
-#[turbo_tasks::value_impl]
-impl ChunkableModule for EcmascriptClientReferenceModule {
-    #[turbo_tasks::function]
-    async fn as_chunk_item(
-        self: ResolvedVc<Self>,
-        module_graph: Vc<ModuleGraph>,
-        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    ) -> Result<Vc<Box<dyn ChunkItem>>> {
-        Ok(ecmascript_chunk_item(
-            ResolvedVc::upcast(self),
-            module_graph.to_resolved().await?,
-            chunking_context,
-        ))
-    }
-}
-
 #[turbo_tasks::value_impl]
 impl EcmascriptChunkPlaceable for EcmascriptClientReferenceModule {
     #[turbo_tasks::function]
@@ -279,8 +257,12 @@ impl EcmascriptChunkPlaceable for EcmascriptClientReferenceModule {
         async_module_info: Option<Vc<AsyncModuleInfo>>,
         estimated: bool,
     ) -> Vc<EcmascriptChunkItemContent> {
-        self.proxy_module()
-            .chunk_item_content(chunking_context, module_graph, async_module_info, estimated)
+        self.proxy_module().chunk_item_content(
+            chunking_context,
+            module_graph,
+            async_module_info,
+            estimated,
+        )
     }
 }
 

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

@@ -5,7 +5,7 @@ use indoc::formatdoc;
 use turbo_rcstr::{RcStr, rcstr};
 use turbo_tasks::{ResolvedVc, Vc};
 use turbopack_core::{
-    chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
+    chunk::{AsyncModuleInfo, ChunkingContext, ModuleChunkItemIdExt},
     ident::AssetIdent,
     module::{Module, ModuleSideEffects},
     module_graph::ModuleGraph,
@@ -14,10 +14,7 @@ use turbopack_core::{
     source::OptionSource,
 };
 use turbopack_ecmascript::{
-    chunk::{
-        EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports,
-        ecmascript_chunk_item,
-    },
+    chunk::{EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports},
     references::esm::{EsmExport, EsmExports},
     runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
     utils::StringifyJs,
@@ -75,18 +72,6 @@ impl Module for NextDynamicEntryModule {
     }
 }
 
-#[turbo_tasks::value_impl]
-impl ChunkableModule for NextDynamicEntryModule {
-    #[turbo_tasks::function]
-    fn as_chunk_item(
-        self: ResolvedVc<Self>,
-        module_graph: ResolvedVc<ModuleGraph>,
-        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    ) -> Vc<Box<dyn turbopack_core::chunk::ChunkItem>> {
-        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
-    }
-}
-
 #[turbo_tasks::value_impl]
 impl EcmascriptChunkPlaceable for NextDynamicEntryModule {
     #[turbo_tasks::function]

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

@@ -6,18 +6,15 @@ use turbo_rcstr::rcstr;
 use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::{
-    chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
+    chunk::{AsyncModuleInfo, ChunkingContext, ModuleChunkItemIdExt},
     ident::AssetIdent,
     module::{Module, ModuleSideEffects},
     module_graph::ModuleGraph,
     reference::ModuleReferences,
     source::OptionSource,
 };
 use turbopack_ecmascript::{
-    chunk::{
-        EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports,
-        ecmascript_chunk_item,
-    },
+    chunk::{EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports},
     references::esm::{EsmExport, EsmExports},
     runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
     utils::StringifyJs,
@@ -92,18 +89,6 @@ impl Module for NextServerComponentModule {
     }
 }
 
-#[turbo_tasks::value_impl]
-impl ChunkableModule for NextServerComponentModule {
-    #[turbo_tasks::function]
-    fn as_chunk_item(
-        self: ResolvedVc<Self>,
-        module_graph: ResolvedVc<ModuleGraph>,
-        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    ) -> Vc<Box<dyn turbopack_core::chunk::ChunkItem>> {
-        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
-    }
-}
-
 #[turbo_tasks::value_impl]
 impl EcmascriptChunkPlaceable for NextServerComponentModule {
     #[turbo_tasks::function]

crates/next-core/src/next_server_utility/server_utility_module.rs

@@ -6,18 +6,15 @@ use turbo_rcstr::rcstr;
 use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::FileSystemPath;
 use turbopack_core::{
-    chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext, ModuleChunkItemIdExt},
+    chunk::{AsyncModuleInfo, ChunkingContext, ModuleChunkItemIdExt},
     ident::AssetIdent,
     module::{Module, ModuleSideEffects},
     module_graph::ModuleGraph,
     reference::ModuleReferences,
     source::OptionSource,
 };
 use turbopack_ecmascript::{
-    chunk::{
-        EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports,
-        ecmascript_chunk_item,
-    },
+    chunk::{EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports},
     references::esm::{EsmExport, EsmExports},
     runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
     utils::StringifyJs,
@@ -73,18 +70,6 @@ impl Module for NextServerUtilityModule {
     }
 }
 
-#[turbo_tasks::value_impl]
-impl ChunkableModule for NextServerUtilityModule {
-    #[turbo_tasks::function]
-    fn as_chunk_item(
-        self: ResolvedVc<Self>,
-        module_graph: ResolvedVc<ModuleGraph>,
-        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    ) -> Vc<Box<dyn turbopack_core::chunk::ChunkItem>> {
-        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
-    }
-}
-
 #[turbo_tasks::value_impl]
 impl EcmascriptChunkPlaceable for NextServerUtilityModule {
     #[turbo_tasks::function]

crates/next-core/src/raw_ecmascript_module.rs

@@ -11,7 +11,7 @@ use turbo_tasks_fs::{FileContent, rope::Rope};
 use turbopack::{ModuleAssetContext, module_options::CustomModuleType};
 use turbopack_core::{
     asset::Asset,
-    chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext},
+    chunk::{AsyncModuleInfo, ChunkingContext},
     code_builder::CodeBuilder,
     compile_time_info::{
         CompileTimeDefineValue, CompileTimeInfo, DefinableNameSegmentRef, DefinableNameSegmentRefs,
@@ -29,7 +29,7 @@ use turbopack_ecmascript::{
     EcmascriptInputTransforms,
     chunk::{
         EcmascriptChunkItemContent, EcmascriptChunkItemOptions, EcmascriptChunkPlaceable,
-        EcmascriptExports, ecmascript_chunk_item,
+        EcmascriptExports,
     },
     source_map::{extract_source_mapping_url_from_content, parse_source_map_comment},
     utils::StringifyJs,
@@ -104,18 +104,6 @@ impl Module for RawEcmascriptModule {
     }
 }
 
-#[turbo_tasks::value_impl]
-impl ChunkableModule for RawEcmascriptModule {
-    #[turbo_tasks::function]
-    fn as_chunk_item(
-        self: ResolvedVc<Self>,
-        module_graph: ResolvedVc<ModuleGraph>,
-        chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
-    ) -> Vc<Box<dyn turbopack_core::chunk::ChunkItem>> {
-        ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
-    }
-}
-
 #[turbo_tasks::value_impl]
 impl EcmascriptChunkPlaceable for RawEcmascriptModule {
     #[turbo_tasks::function]