Turbopack: align chunking with graph entries (#76441)

Shouldn't have any change in behavior, but prepares for #76211

Author: mischnic

crates/next-api/src/app.rs

@@ -31,7 +31,7 @@ use next_core::{
         get_server_module_options_context, get_server_resolve_options_context,
         get_server_runtime_entries, ServerContextType,
     },
-    next_server_utility::NextServerUtilityTransition,
+    next_server_utility::{NextServerUtilityTransition, NEXT_SERVER_UTILITY_MERGE_TAG},
     parse_segment_config_from_source,
     util::NextRuntime,
 };
@@ -53,14 +53,15 @@ use turbopack::{
 use turbopack_core::{
     asset::AssetContent,
     chunk::{
-        availability_info::AvailabilityInfo, ChunkGroupType, ChunkingContext, ChunkingContextExt,
+        availability_info::AvailabilityInfo, ChunkGroupResult, ChunkingContext, ChunkingContextExt,
         EvaluatableAsset, EvaluatableAssets,
     },
     file_source::FileSource,
     ident::AssetIdent,
     module::Module,
     module_graph::{
-        chunk_group_info::ChunkGroup, GraphEntries, ModuleGraph, SingleModuleGraph, VisitedModules,
+        chunk_group_info::{ChunkGroup, ChunkGroupEntry},
+        GraphEntries, ModuleGraph, SingleModuleGraph, VisitedModules,
     },
     output::{OutputAsset, OutputAssets},
     raw_output::RawOutput,
@@ -826,6 +827,9 @@ impl AppProject {
             // Implements layout segment optimization to compute a graph "chain" for each layout
             // segment
             async move {
+                let rsc_entry_chunk_group =
+                    ChunkGroupEntry::Entry(vec![ResolvedVc::upcast(rsc_entry)]);
+
                 let mut graphs = vec![];
                 let mut visited_modules = if has_layout_segments {
                     let ServerEntries {
@@ -835,15 +839,16 @@ impl AppProject {
 
                     let graph = SingleModuleGraph::new_with_entries_visited_intern(
                         vec![
-                            (
-                                server_utils
+                            ChunkGroupEntry::SharedMerged {
+                                parent: Box::new(rsc_entry_chunk_group.clone()),
+                                merge_tag: NEXT_SERVER_UTILITY_MERGE_TAG.clone(),
+                                entries: server_utils
                                     .iter()
                                     .map(async |m| Ok(ResolvedVc::upcast(m.await?.module)))
                                     .try_join()
                                     .await?,
-                                ChunkGroupType::Entry,
-                            ),
-                            (client_shared_entries, ChunkGroupType::Evaluated),
+                            },
+                            ChunkGroupEntry::Entry(client_shared_entries),
                         ],
                         VisitedModules::empty(),
                     );
@@ -852,7 +857,9 @@ impl AppProject {
 
                     for module in server_component_entries.iter() {
                         let graph = SingleModuleGraph::new_with_entries_visited_intern(
-                            vec![(vec![ResolvedVc::upcast(*module)], ChunkGroupType::Entry)],
+                            // This should really be ChunkGroupEntry::Shared(module.await?.module),
+                            // but that breaks everything for some reason.
+                            vec![ChunkGroupEntry::Entry(vec![ResolvedVc::upcast(*module)])],
                             visited_modules,
                         );
                         graphs.push(graph);
@@ -873,15 +880,15 @@ impl AppProject {
                     visited_modules
                 } else {
                     let graph = SingleModuleGraph::new_with_entries_visited_intern(
-                        vec![(client_shared_entries, ChunkGroupType::Evaluated)],
+                        vec![ChunkGroupEntry::Entry(client_shared_entries)],
                         VisitedModules::empty(),
                     );
                     graphs.push(graph);
                     VisitedModules::from_graph(graph)
                 };
 
                 let graph = SingleModuleGraph::new_with_entries_visited_intern(
-                    vec![(vec![ResolvedVc::upcast(rsc_entry)], ChunkGroupType::Entry)],
+                    vec![rsc_entry_chunk_group],
                     visited_modules,
                 );
                 graphs.push(graph);
@@ -1664,25 +1671,35 @@ impl AppEndpoint {
 
         Ok(match runtime {
             NextRuntime::Edge => {
+                let ChunkGroupResult {
+                    assets,
+                    availability_info,
+                } = *chunking_context
+                    .evaluated_chunk_group(
+                        server_action_manifest_loader.ident(),
+                        Vc::cell(vec![server_action_manifest_loader]),
+                        module_graph,
+                        Value::new(AvailabilityInfo::Root),
+                    )
+                    .await?;
+
                 let mut evaluatable_assets =
                     this.app_project.edge_rsc_runtime_entries().owned().await?;
                 let evaluatable = ResolvedVc::try_sidecast(app_entry.rsc_entry)
                     .context("Entry module must be evaluatable")?;
                 evaluatable_assets.push(evaluatable);
-                evaluatable_assets.push(server_action_manifest_loader);
 
-                {
-                    let _span = tracing::info_span!("Server Components");
+                assets.concatenate(
                     chunking_context
                         .evaluated_chunk_group_assets(
                             app_entry.rsc_entry.ident(),
                             Vc::cell(evaluatable_assets.clone()),
                             module_graph,
-                            Value::new(AvailabilityInfo::Root),
+                            Value::new(availability_info),
                         )
                         .resolve()
-                        .await?
-                }
+                        .await?,
+                )
             }
             NextRuntime::NodeJs => {
                 let mut evaluatable_assets = this.app_project.rsc_runtime_entries().owned().await?;
@@ -1712,10 +1729,7 @@ impl AppEndpoint {
                                 AssetIdent::from_path(this.app_project.project().project_path())
                                     .with_modifier(server_utils_modifier()),
                                 // TODO this should be ChunkGroup::Shared
-                                ChunkGroup::Entry {
-                                    entries: server_utils,
-                                    ty: ChunkGroupType::Entry,
-                                },
+                                ChunkGroup::Entry(server_utils),
                                 module_graph,
                                 Value::new(current_availability_info),
                             )
@@ -1751,12 +1765,9 @@ impl AppEndpoint {
                                 .chunk_group(
                                     server_component.ident(),
                                     // TODO this should be ChunkGroup::Shared
-                                    ChunkGroup::Entry {
-                                        entries: vec![ResolvedVc::upcast(
-                                            server_component.await?.module,
-                                        )],
-                                        ty: ChunkGroupType::Entry,
-                                    },
+                                    ChunkGroup::Entry(vec![ResolvedVc::upcast(
+                                        server_component.await?.module,
+                                    )]),
                                     module_graph,
                                     Value::new(current_availability_info),
                                 )
@@ -1930,19 +1941,15 @@ impl Endpoint for AppEndpoint {
     async fn entries(self: Vc<Self>) -> Result<Vc<GraphEntries>> {
         let this = self.await?;
         Ok(Vc::cell(vec![
-            (
-                vec![self.app_endpoint_entry().await?.rsc_entry],
-                ChunkGroupType::Entry,
-            ),
-            (
+            ChunkGroupEntry::Entry(vec![self.app_endpoint_entry().await?.rsc_entry]),
+            ChunkGroupEntry::Entry(
                 this.app_project
                     .client_runtime_entries()
                     .await?
                     .iter()
                     .copied()
                     .map(ResolvedVc::upcast)
                     .collect(),
-                ChunkGroupType::Entry,
             ),
         ]))
     }
@@ -1983,10 +1990,9 @@ impl Endpoint for AppEndpoint {
             .await?,
         );
 
-        Ok(Vc::cell(vec![(
-            vec![server_actions_loader],
-            ChunkGroupType::Entry,
-        )]))
+        Ok(Vc::cell(vec![ChunkGroupEntry::Entry(vec![
+            server_actions_loader,
+        ])]))
     }
 }
 

crates/next-api/src/instrumentation.rs

@@ -12,12 +12,12 @@ use turbo_tasks_fs::{File, FileContent, FileSystemPath};
 use turbopack_core::{
     asset::AssetContent,
     chunk::{
-        availability_info::AvailabilityInfo, ChunkGroupType, ChunkingContext, ChunkingContextExt,
+        availability_info::AvailabilityInfo, ChunkingContext, ChunkingContextExt,
         EntryChunkGroupResult,
     },
     context::AssetContext,
     module::Module,
-    module_graph::GraphEntries,
+    module_graph::{chunk_group_info::ChunkGroupEntry, GraphEntries},
     output::{OutputAsset, OutputAssets},
     reference_type::{EntryReferenceSubType, ReferenceType},
     source::Source,
@@ -95,24 +95,13 @@ impl InstrumentationEndpoint {
         .cell())
     }
 
-    #[turbo_tasks::function]
-    async fn entry_module(self: Vc<Self>) -> Result<Vc<Box<dyn Module>>> {
-        if self.await?.is_edge {
-            Ok(*self.core_modules().await?.edge_entry_module)
-        } else {
-            Ok(*self.core_modules().await?.userland_module)
-        }
-    }
-
     #[turbo_tasks::function]
     async fn edge_files(self: Vc<Self>) -> Result<Vc<OutputAssets>> {
         let this = self.await?;
 
         let module = self.core_modules().await?.edge_entry_module;
 
-        let module_graph = this
-            .project
-            .module_graph(*module, ChunkGroupType::Evaluated);
+        let module_graph = this.project.module_graph(*module);
 
         let mut evaluatable_assets = get_server_runtime_entries(
             Value::new(ServerContextType::Instrumentation {
@@ -155,9 +144,7 @@ impl InstrumentationEndpoint {
         let chunking_context = this.project.server_chunking_context(false);
 
         let userland_module = self.core_modules().await?.userland_module;
-        let module_graph = this
-            .project
-            .module_graph(*userland_module, ChunkGroupType::Entry);
+        let module_graph = this.project.module_graph(*userland_module);
 
         let Some(module) = ResolvedVc::try_downcast(userland_module) else {
             bail!("Entry module must be evaluatable");
@@ -294,9 +281,12 @@ impl Endpoint for InstrumentationEndpoint {
     #[turbo_tasks::function]
     async fn entries(self: Vc<Self>) -> Result<Vc<GraphEntries>> {
         let core_modules = self.core_modules().await?;
-        Ok(Vc::cell(vec![(
-            vec![core_modules.edge_entry_module],
-            ChunkGroupType::Evaluated,
+        Ok(Vc::cell(vec![ChunkGroupEntry::Entry(
+            if self.await?.is_edge {
+                vec![core_modules.edge_entry_module]
+            } else {
+                vec![core_modules.userland_module]
+            },
         )]))
     }
 }

crates/next-api/src/middleware.rs

@@ -16,12 +16,12 @@ use turbo_tasks_fs::{self, File, FileContent, FileSystemPath};
 use turbopack_core::{
     asset::AssetContent,
     chunk::{
-        availability_info::AvailabilityInfo, ChunkGroupType, ChunkingContext, ChunkingContextExt,
+        availability_info::AvailabilityInfo, ChunkingContext, ChunkingContextExt,
         EntryChunkGroupResult, EvaluatableAsset,
     },
     context::AssetContext,
     module::Module,
-    module_graph::GraphEntries,
+    module_graph::{chunk_group_info::ChunkGroupEntry, GraphEntries},
     output::{OutputAsset, OutputAssets},
     reference_type::{EntryReferenceSubType, ReferenceType},
     source::Source,
@@ -128,9 +128,7 @@ impl MiddlewareEndpoint {
         evaluatable_assets.push(evaluatable.to_resolved().await?);
 
         let evaluatable_assets = Vc::cell(evaluatable_assets);
-        let module_graph = this
-            .project
-            .module_graph_for_entries(evaluatable_assets, ChunkGroupType::Evaluated);
+        let module_graph = this.project.module_graph_for_entries(evaluatable_assets);
 
         let edge_chunking_context = this.project.edge_chunking_context(false);
 
@@ -150,9 +148,7 @@ impl MiddlewareEndpoint {
         let chunking_context = this.project.server_chunking_context(false);
 
         let userland_module = self.entry_module().to_resolved().await?;
-        let module_graph = this
-            .project
-            .module_graph(*userland_module, ChunkGroupType::Entry);
+        let module_graph = this.project.module_graph(*userland_module);
 
         let Some(module) = ResolvedVc::try_downcast(userland_module) else {
             bail!("Entry module must be evaluatable");
@@ -409,9 +405,8 @@ impl Endpoint for MiddlewareEndpoint {
 
     #[turbo_tasks::function]
     async fn entries(self: Vc<Self>) -> Result<Vc<GraphEntries>> {
-        Ok(Vc::cell(vec![(
-            vec![self.entry_module().to_resolved().await?],
-            ChunkGroupType::Evaluated,
-        )]))
+        Ok(Vc::cell(vec![ChunkGroupEntry::Entry(vec![
+            self.entry_module().to_resolved().await?,
+        ])]))
     }
 }

crates/next-api/src/pages.rs

@@ -45,14 +45,14 @@ use turbopack::{
 use turbopack_core::{
     asset::AssetContent,
     chunk::{
-        availability_info::AvailabilityInfo, ChunkGroupResult, ChunkGroupType, ChunkingContext,
-        ChunkingContextExt, EntryChunkGroupResult, EvaluatableAsset, EvaluatableAssets,
+        availability_info::AvailabilityInfo, ChunkGroupResult, ChunkingContext, ChunkingContextExt,
+        EntryChunkGroupResult, EvaluatableAsset, EvaluatableAssets,
     },
     context::AssetContext,
     file_source::FileSource,
     ident::AssetIdent,
     module::Module,
-    module_graph::{GraphEntries, ModuleGraph},
+    module_graph::{chunk_group_info::ChunkGroupEntry, GraphEntries, ModuleGraph},
     output::{OptionOutputAsset, OutputAsset, OutputAssets},
     reference_type::{EcmaScriptModulesReferenceSubType, EntryReferenceSubType, ReferenceType},
     resolve::{origin::PlainResolveOrigin, parse::Request, pattern::Pattern},
@@ -769,7 +769,7 @@ impl PageEndpoint {
         let this = self.await?;
         let project = this.pages_project.project();
         let evaluatable_assets = self.client_evaluatable_assets();
-        Ok(project.module_graph_for_entries(evaluatable_assets, ChunkGroupType::Evaluated))
+        Ok(project.module_graph_for_entries(evaluatable_assets))
     }
 
     #[turbo_tasks::function]
@@ -909,7 +909,7 @@ impl PageEndpoint {
             // The SSR and Client Graphs are not connected in Pages Router.
             // We are only interested in get_next_dynamic_imports_for_endpoint at the
             // moment, which only needs the client graph anyway.
-            let module_graph = project.module_graph(*ssr_module, ChunkGroupType::Entry);
+            let module_graph = project.module_graph(*ssr_module);
 
             let next_dynamic_imports = if let PageEndpointType::Html = this.ty {
                 let client_availability_info = self.client_chunks().await?.availability_info;
@@ -1454,19 +1454,17 @@ impl Endpoint for PageEndpoint {
     #[turbo_tasks::function]
     async fn entries(self: Vc<Self>) -> Result<Vc<GraphEntries>> {
         let this = self.await?;
-        let mut modules = vec![];
 
         let ssr_chunk_module = self.internal_ssr_chunk_module().await?;
-        modules.push((vec![ssr_chunk_module.ssr_module], ChunkGroupType::Entry));
+        let mut modules = vec![ChunkGroupEntry::Entry(vec![ssr_chunk_module.ssr_module])];
 
         if let PageEndpointType::Html = this.ty {
-            modules.push((
+            modules.push(ChunkGroupEntry::Entry(
                 self.client_evaluatable_assets()
                     .await?
                     .iter()
                     .map(|m| ResolvedVc::upcast(*m))
                     .collect(),
-                ChunkGroupType::Evaluated,
             ));
         }