remove additional_entries

Author: mischnic

crates/next-api/src/analyze.rs

@@ -16,12 +16,11 @@ use turbopack_core::{
     asset::{Asset, AssetContent},
     chunk::ChunkingType,
     module::Module,
+    module_graph::ModuleGraph,
     output::{OutputAsset, OutputAssets, OutputAssetsReference},
     reference::all_assets_from_entries,
 };
 
-use crate::route::ModuleGraphs;
-
 pub struct EdgesData {
     pub offsets: Vec<u32>,
     pub data: Vec<u32>,
@@ -431,30 +430,28 @@ pub async fn analyze_output_assets(output_assets: Vc<OutputAssets>) -> Result<Vc
 }
 
 #[turbo_tasks::function]
-pub async fn analyze_module_graphs(module_graphs: Vc<ModuleGraphs>) -> Result<Vc<FileContent>> {
+pub async fn analyze_module_graph(module_graph: Vc<ModuleGraph>) -> Result<Vc<FileContent>> {
     let mut builder = ModulesDataBuilder::new();
 
     let mut all_modules = FxIndexSet::default();
     let mut all_edges = FxIndexSet::default();
     let mut all_async_edges = FxIndexSet::default();
-    for &module_graph in module_graphs.await? {
-        let module_graph = module_graph.await?;
-        module_graph.traverse_edges_unordered(|parent, node| {
-            if let Some((parent_node, reference)) = parent {
-                all_modules.insert(parent_node);
-                all_modules.insert(node);
-                match reference.chunking_type {
-                    ChunkingType::Async => {
-                        all_async_edges.insert((parent_node, node));
-                    }
-                    _ => {
-                        all_edges.insert((parent_node, node));
-                    }
+    let module_graph = module_graph.await?;
+    module_graph.traverse_edges_unordered(|parent, node| {
+        if let Some((parent_node, reference)) = parent {
+            all_modules.insert(parent_node);
+            all_modules.insert(node);
+            match reference.chunking_type {
+                ChunkingType::Async => {
+                    all_async_edges.insert((parent_node, node));
+                }
+                _ => {
+                    all_edges.insert((parent_node, node));
                 }
             }
-            Ok(())
-        })?;
-    }
+        }
+        Ok(())
+    })?;
 
     type ModulePair = (ResolvedVc<Box<dyn Module>>, ResolvedVc<Box<dyn Module>>);
     async fn mapper((from, to): ModulePair) -> Result<Option<(RcStr, RcStr)>> {
@@ -568,26 +565,22 @@ impl OutputAsset for AnalyzeDataOutputAsset {
 #[turbo_tasks::value]
 pub struct ModulesDataOutputAsset {
     pub path: FileSystemPath,
-    pub module_graphs: ResolvedVc<ModuleGraphs>,
+    pub module_graph: ResolvedVc<ModuleGraph>,
 }
 
 #[turbo_tasks::value_impl]
 impl ModulesDataOutputAsset {
     #[turbo_tasks::function]
-    pub async fn new(path: FileSystemPath, module_graphs: Vc<ModuleGraphs>) -> Result<Vc<Self>> {
-        Ok(Self {
-            path,
-            module_graphs: module_graphs.to_resolved().await?,
-        }
-        .cell())
+    pub fn new(path: FileSystemPath, module_graph: ResolvedVc<ModuleGraph>) -> Vc<Self> {
+        Self { path, module_graph }.cell()
     }
 }
 
 #[turbo_tasks::value_impl]
 impl Asset for ModulesDataOutputAsset {
     #[turbo_tasks::function]
     fn content(&self) -> Vc<AssetContent> {
-        let file_content = analyze_module_graphs(*self.module_graphs);
+        let file_content = analyze_module_graph(*self.module_graph);
         AssetContent::file(file_content)
     }
 }

crates/next-api/src/app.rs

@@ -88,7 +88,7 @@ use crate::{
         all_asset_paths, all_paths_in_root, get_asset_paths_from_root, get_js_paths_from_root,
         get_wasm_paths_from_root, paths_to_bindings, wasm_paths_to_bindings,
     },
-    project::{BaseAndFullModuleGraph, Project},
+    project::Project,
     route::{
         AppPageRoute, Endpoint, EndpointOutput, EndpointOutputPaths, ModuleGraphs, Route, Routes,
     },
@@ -976,14 +976,13 @@ impl AppProject {
     }
 
     #[turbo_tasks::function]
-    pub async fn app_module_graphs(
+    pub async fn app_module_graph(
         &self,
-        endpoint: Vc<AppEndpoint>,
         rsc_entry: ResolvedVc<Box<dyn Module>>,
         server_action_loader_module: ResolvedVc<Box<dyn Module>>,
         client_shared_entries: Vc<EvaluatableAssets>,
         has_layout_segments: bool,
-    ) -> Result<Vc<BaseAndFullModuleGraph>> {
+    ) -> Result<Vc<ModuleGraph>> {
         if *self.project.per_page_module_graph().await? {
             let next_mode = self.project.next_mode();
             let next_mode_ref = next_mode.await?;
@@ -1002,7 +1001,7 @@ impl AppProject {
                     ChunkGroupEntry::Entry(vec![server_action_loader_module, rsc_entry]);
 
                 let mut graphs = vec![];
-                let mut visited_modules = if has_layout_segments {
+                let visited_modules = if has_layout_segments {
                     let ServerEntries {
                         server_utils,
                         server_component_entries,
@@ -1075,50 +1074,33 @@ impl AppProject {
                     should_read_binding_usage,
                 );
                 graphs.push(graph);
-                visited_modules = VisitedModules::concatenate(visited_modules, graph);
-
-                let base = ModuleGraph::from_graphs(graphs.clone(), None);
-                let additional_entries = endpoint.additional_entries(base.connect());
-                let additional_module_graph = SingleModuleGraph::new_with_entries_visited_intern(
-                    additional_entries.owned().await?,
-                    visited_modules,
-                    should_trace,
-                    should_read_binding_usage,
-                );
-                graphs.push(additional_module_graph);
 
                 let remove_unused_imports = *self
                     .project
                     .next_config()
                     .turbopack_remove_unused_imports(next_mode)
                     .await?;
+                let remove_unused_exports = *self
+                    .project
+                    .next_config()
+                    .turbopack_remove_unused_exports(next_mode)
+                    .await?;
 
-                let (full, binding_usage_info) = if remove_unused_imports {
-                    let full_with_unused_references =
-                        ModuleGraph::from_graphs(graphs.clone(), None);
-                    let binding_usage_info = compute_binding_usage_info(
-                        full_with_unused_references,
-                        should_read_binding_usage,
-                    );
-                    (
-                        ModuleGraph::from_graphs(graphs, Some(binding_usage_info)),
-                        Some(binding_usage_info),
-                    )
+                let graph = if remove_unused_imports || remove_unused_exports {
+                    let graph = ModuleGraph::from_graphs(graphs.clone(), None);
+                    let binding_usage_info =
+                        compute_binding_usage_info(graph, remove_unused_imports);
+                    ModuleGraph::from_graphs(graphs, Some(binding_usage_info))
                 } else {
-                    (ModuleGraph::from_graphs(graphs, None), None)
+                    ModuleGraph::from_graphs(graphs, None)
                 };
 
-                Ok(BaseAndFullModuleGraph {
-                    base: base.connect().to_resolved().await?,
-                    full: full.connect().to_resolved().await?,
-                    binding_usage_info,
-                }
-                .cell())
+                Ok(graph.connect())
             }
             .instrument(tracing::info_span!("module graph for endpoint"))
             .await
         } else {
-            Ok(self.project.whole_app_module_graphs())
+            Ok(self.project.whole_app_module_graph())
         }
     }
 }
@@ -1382,21 +1364,17 @@ impl AppEndpoint {
 
         let server_action_loader = self.server_action_loader_module();
 
-        let module_graphs = this
-            .app_project
-            .app_module_graphs(
-                self,
-                *rsc_entry,
-                server_action_loader,
-                // We only need the client runtime entries for pages not for Route Handlers
-                if is_app_page {
-                    this.app_project.client_runtime_entries()
-                } else {
-                    EvaluatableAssets::empty()
-                },
-                is_app_page,
-            )
-            .await?;
+        let module_graph = this.app_project.app_module_graph(
+            *rsc_entry,
+            server_action_loader,
+            // We only need the client runtime entries for pages not for Route Handlers
+            if is_app_page {
+                this.app_project.client_runtime_entries()
+            } else {
+                EvaluatableAssets::empty()
+            },
+            is_app_page,
+        );
 
         let client_chunking_context = project.client_chunking_context().to_resolved().await?;
 
@@ -1422,7 +1400,7 @@ impl AppEndpoint {
                 AssetIdent::from_path(project.project_path().owned().await?)
                     .with_modifier(rcstr!("client-shared-chunks")),
                 this.app_project.client_runtime_entries(),
-                *module_graphs.full,
+                module_graph,
                 *client_chunking_context,
             );
 
@@ -1439,27 +1417,25 @@ impl AppEndpoint {
 
         let per_page_module_graph = *project.per_page_module_graph().await?;
 
-        let next_dynamic_imports =
-            NextDynamicGraphs::new(*module_graphs.base, per_page_module_graph)
-                .get_next_dynamic_imports_for_endpoint(*rsc_entry)
-                .await?;
+        let next_dynamic_imports = NextDynamicGraphs::new(module_graph, per_page_module_graph)
+            .get_next_dynamic_imports_for_endpoint(*rsc_entry)
+            .await?;
 
         let is_production = project.next_mode().await?.is_production();
 
-        let client_references =
-            ClientReferencesGraphs::new(*module_graphs.base, per_page_module_graph)
-                .get_client_references_for_endpoint(
-                    *rsc_entry,
-                    matches!(this.ty, AppEndpointType::Page { .. }),
-                    is_production,
-                    is_production,
-                )
-                .to_resolved()
-                .await?;
+        let client_references = ClientReferencesGraphs::new(module_graph, per_page_module_graph)
+            .get_client_references_for_endpoint(
+                *rsc_entry,
+                matches!(this.ty, AppEndpointType::Page { .. }),
+                is_production,
+                is_production,
+            )
+            .to_resolved()
+            .await?;
 
         let client_references_chunks = get_app_client_references_chunks(
             *client_references,
-            *module_graphs.full,
+            module_graph,
             *client_chunking_context,
             availability_info,
             ssr_chunking_context.map(|ctx| *ctx),
@@ -1541,7 +1517,7 @@ impl AppEndpoint {
                 .await?
             {
                 let webpack_stats = generate_webpack_stats(
-                    *module_graphs.base,
+                    module_graph,
                     app_entry.original_name.clone(),
                     client_assets.await?.into_iter().copied(),
                 )
@@ -1595,7 +1571,7 @@ impl AppEndpoint {
                     node_root.clone(),
                     app_entry.original_name.clone(),
                     runtime,
-                    *module_graphs.full,
+                    module_graph,
                     this.app_project
                         .project()
                         .runtime_chunking_context(process_client_assets, runtime),
@@ -1610,7 +1586,7 @@ impl AppEndpoint {
                 *client_references,
                 server_path.clone(),
                 process_client_assets,
-                *module_graphs.full,
+                module_graph,
             )
             .to_resolved()
             .await?;
@@ -1632,7 +1608,7 @@ impl AppEndpoint {
                     client_references_chunks,
                     client_chunking_context,
                     ssr_chunking_context,
-                    async_module_info: module_graphs.full.async_module_info().to_resolved().await?,
+                    async_module_info: module_graph.async_module_info().to_resolved().await?,
                     next_config: project.next_config().to_resolved().await?,
                     runtime,
                     mode: *project.next_mode().await?,
@@ -1715,7 +1691,7 @@ impl AppEndpoint {
 
                 if emit_manifests == EmitManifests::Full {
                     let dynamic_import_entries = collect_next_dynamic_chunks(
-                        *module_graphs.full,
+                        module_graph,
                         *client_chunking_context,
                         next_dynamic_imports,
                         NextDynamicChunkAvailability::ClientReferences(
@@ -1831,7 +1807,7 @@ impl AppEndpoint {
                 let loadable_manifest_output = if emit_manifests == EmitManifests::Full {
                     // create react-loadable-manifest for next/dynamic
                     let dynamic_import_entries = collect_next_dynamic_chunks(
-                        *module_graphs.full,
+                        module_graph,
                         *client_chunking_context,
                         next_dynamic_imports,
                         NextDynamicChunkAvailability::ClientReferences(
@@ -2203,17 +2179,17 @@ impl Endpoint for AppEndpoint {
         let this = self.await?;
         let app_entry = self.app_endpoint_entry().await?;
         let server_action_loader = self.server_action_loader_module();
-        let module_graphs = this
+        let module_graph = this
             .app_project
-            .app_module_graphs(
-                self,
+            .app_module_graph(
                 *app_entry.rsc_entry,
                 server_action_loader,
                 this.app_project.client_runtime_entries(),
                 matches!(this.ty, AppEndpointType::Page { .. }),
             )
+            .to_resolved()
             .await?;
-        Ok(Vc::cell(vec![module_graphs.full]))
+        Ok(Vc::cell(vec![module_graph]))
     }
 
     #[turbo_tasks::function]

crates/next-api/src/pages.rs

@@ -752,18 +752,22 @@ impl PageEndpoint {
                 .next_config()
                 .turbopack_remove_unused_imports(next_mode)
                 .await?;
+            let remove_unused_exports = *project
+                .next_config()
+                .turbopack_remove_unused_exports(next_mode)
+                .await?;
 
-            let graph = if remove_unused_imports {
+            let graph = if remove_unused_imports || remove_unused_exports {
                 let graph = ModuleGraph::from_graphs(graphs.clone(), None);
-                let binding_usage_info = compute_binding_usage_info(graph, true);
+                let binding_usage_info = compute_binding_usage_info(graph, remove_unused_imports);
                 ModuleGraph::from_graphs(graphs, Some(binding_usage_info))
             } else {
                 ModuleGraph::from_graphs(graphs, None)
             };
 
             Ok(graph.connect())
         } else {
-            Ok(*project.whole_app_module_graphs().await?.full)
+            Ok(project.whole_app_module_graph())
         }
     }
 
@@ -1733,6 +1737,7 @@ impl Endpoint for PageEndpoint {
     async fn module_graphs(self: Vc<Self>) -> Result<Vc<ModuleGraphs>> {
         let client_module_graph = self.client_module_graph().to_resolved().await?;
         let ssr_module_graph = self.ssr_module_graph().to_resolved().await?;
+        // TODO refactor this so that there is a single module graph
         Ok(Vc::cell(if client_module_graph != ssr_module_graph {
             vec![client_module_graph, ssr_module_graph]
         } else {