From f09642870173ab403efb490d2af250c53e8d6de9 Mon Sep 17 00:00:00 2001 From: Will Binns-Smith Date: Mon, 3 Feb 2025 13:18:14 +0100 Subject: [PATCH] Skip Traced chunking type in module graph --- .../visit_client_reference.rs | 141 ++++++++++-------- .../turbopack-core/src/module_graph/mod.rs | 71 ++++++--- 2 files changed, 127 insertions(+), 85 deletions(-) diff --git a/crates/next-core/src/next_client_reference/visit_client_reference.rs b/crates/next-core/src/next_client_reference/visit_client_reference.rs index 13f589db7d7916..4268d4fbaa0aea 100644 --- a/crates/next-core/src/next_client_reference/visit_client_reference.rs +++ b/crates/next-core/src/next_client_reference/visit_client_reference.rs @@ -12,7 +12,9 @@ use turbo_tasks::{ }; use turbo_tasks_fs::FileSystemPath; use turbopack::css::chunk::CssChunkPlaceable; -use turbopack_core::{module::Module, reference::primary_referenced_modules}; +use turbopack_core::{ + chunk::ChunkingType, module::Module, reference::primary_chunkable_referenced_modules, +}; use crate::{ next_client_reference::{ @@ -402,79 +404,86 @@ impl Visit for VisitClientReference { } }; - let referenced_modules = primary_referenced_modules(*parent_module).await?; + let referenced_modules = primary_chunkable_referenced_modules(*parent_module).await?; - let referenced_modules = referenced_modules.iter().map(|module| async move { - if let Some(client_reference_module) = - ResolvedVc::try_downcast_type::(*module) - .await? - { - return Ok(VisitClientReferenceNode { - state: node.state, - ty: VisitClientReferenceNodeType::ClientReference( - ClientReference { - server_component: node.state.server_component(), - ty: ClientReferenceType::EcmascriptClientReference( - client_reference_module, - ), - }, - client_reference_module.ident().to_string().await?, - ), - }); - } + let referenced_modules = referenced_modules + .iter() + .flat_map(|(chunking_type, modules)| match chunking_type { + ChunkingType::Traced => None, + _ => Some(modules.iter()), + }) + .flatten() + .map(|module| async move { + if let Some(client_reference_module) = + ResolvedVc::try_downcast_type::(*module) + .await? + { + return Ok(VisitClientReferenceNode { + state: node.state, + ty: VisitClientReferenceNodeType::ClientReference( + ClientReference { + server_component: node.state.server_component(), + ty: ClientReferenceType::EcmascriptClientReference( + client_reference_module, + ), + }, + client_reference_module.ident().to_string().await?, + ), + }); + } - if let Some(client_reference_module) = - ResolvedVc::try_downcast_type::(*module).await? - { - return Ok(VisitClientReferenceNode { - state: node.state, - ty: VisitClientReferenceNodeType::ClientReference( - ClientReference { - server_component: node.state.server_component(), - ty: ClientReferenceType::CssClientReference( - client_reference_module.await?.client_module, - ), + if let Some(client_reference_module) = + ResolvedVc::try_downcast_type::(*module).await? + { + return Ok(VisitClientReferenceNode { + state: node.state, + ty: VisitClientReferenceNodeType::ClientReference( + ClientReference { + server_component: node.state.server_component(), + ty: ClientReferenceType::CssClientReference( + client_reference_module.await?.client_module, + ), + }, + client_reference_module.ident().to_string().await?, + ), + }); + } + + if let Some(server_component_asset) = + ResolvedVc::try_downcast_type::(*module).await? + { + return Ok(VisitClientReferenceNode { + state: VisitClientReferenceNodeState::InServerComponent { + server_component: server_component_asset, }, - client_reference_module.ident().to_string().await?, - ), - }); - } + ty: VisitClientReferenceNodeType::ServerComponentEntry( + server_component_asset, + server_component_asset.ident().to_string().await?, + ), + }); + } - if let Some(server_component_asset) = - ResolvedVc::try_downcast_type::(*module).await? - { - return Ok(VisitClientReferenceNode { - state: VisitClientReferenceNodeState::InServerComponent { - server_component: server_component_asset, - }, - ty: VisitClientReferenceNodeType::ServerComponentEntry( - server_component_asset, - server_component_asset.ident().to_string().await?, - ), - }); - } + if ResolvedVc::try_downcast_type::(*module) + .await? + .is_some() + { + return Ok(VisitClientReferenceNode { + state: VisitClientReferenceNodeState::InServerUtil, + ty: VisitClientReferenceNodeType::ServerUtilEntry( + *module, + module.ident().to_string().await?, + ), + }); + } - if ResolvedVc::try_downcast_type::(*module) - .await? - .is_some() - { - return Ok(VisitClientReferenceNode { - state: VisitClientReferenceNodeState::InServerUtil, - ty: VisitClientReferenceNodeType::ServerUtilEntry( + Ok(VisitClientReferenceNode { + state: node.state, + ty: VisitClientReferenceNodeType::Internal( *module, module.ident().to_string().await?, ), - }); - } - - Ok(VisitClientReferenceNode { - state: node.state, - ty: VisitClientReferenceNodeType::Internal( - *module, - module.ident().to_string().await?, - ), - }) - }); + }) + }); let assets = referenced_modules.try_join().await?; diff --git a/turbopack/crates/turbopack-core/src/module_graph/mod.rs b/turbopack/crates/turbopack-core/src/module_graph/mod.rs index bdb2af2a9680ae..e0c0ce59c0e120 100644 --- a/turbopack/crates/turbopack-core/src/module_graph/mod.rs +++ b/turbopack/crates/turbopack-core/src/module_graph/mod.rs @@ -195,18 +195,20 @@ impl SingleModuleGraph { { let _span = tracing::info_span!("build module graph").entered(); for (parent, current) in children_nodes_iter.into_breadth_first_edges() { - let parent_edge = parent.map(|parent| match parent { - SingleModuleGraphBuilderNode::Module { module, .. } => { - (*modules.get(&module).unwrap(), COMMON_CHUNKING_TYPE) + let parent_edge = match parent { + Some(SingleModuleGraphBuilderNode::Module { module, .. }) => { + Some((*modules.get(&module).unwrap(), COMMON_CHUNKING_TYPE)) } - SingleModuleGraphBuilderNode::ChunkableReference { - source, - chunking_type, - .. - } => (*modules.get(&source).unwrap(), chunking_type), - SingleModuleGraphBuilderNode::VisitedModule { .. } - | SingleModuleGraphBuilderNode::Issues { .. } => unreachable!(), - }); + Some(SingleModuleGraphBuilderNode::ChunkableReference { .. }) => { + // Handled when visiting ChunkableReference below + continue; + } + Some( + SingleModuleGraphBuilderNode::VisitedModule { .. } + | SingleModuleGraphBuilderNode::Issues { .. }, + ) => unreachable!(), + None => None, + }; match current { SingleModuleGraphBuilderNode::Module { @@ -248,9 +250,32 @@ impl SingleModuleGraph { graph.add_edge(parent_idx, current_idx, chunking_type); } } - SingleModuleGraphBuilderNode::ChunkableReference { .. } => { - // Ignore. They are handled when visiting the next edge - // (ChunkableReference -> Module) + SingleModuleGraphBuilderNode::ChunkableReference { + source, + target, + target_layer, + chunking_type, + .. + } => { + // Find the current node, if it was already added + let target_idx = if let Some(target_idx) = modules.get(&target) { + *target_idx + } else { + let target_idx = visited_modules.get(&target); + let idx = graph.add_node(match target_idx { + Some(idx) => SingleModuleGraphNode::VisitedModule { idx: *idx }, + None => { + SingleModuleGraphNode::Module(SingleModuleGraphModuleNode { + module: target, + issues: Default::default(), + layer: target_layer, + }) + } + }); + modules.insert(target, idx); + idx + }; + graph.add_edge(*modules.get(&source).unwrap(), target_idx, chunking_type); } SingleModuleGraphBuilderNode::Issues(new_issues) => { let (parent_idx, _) = parent_edge.unwrap(); @@ -975,6 +1000,7 @@ enum SingleModuleGraphBuilderNode { source_ident: ReadRef, target: ResolvedVc>, target_ident: ReadRef, + target_layer: Option>, }, /// A regular module Module { @@ -1015,6 +1041,10 @@ impl SingleModuleGraphBuilderNode { source_ident: source.ident().to_string().await?, target, target_ident: target.ident().to_string().await?, + target_layer: match target.ident().await?.layer { + Some(layer) => Some(layer.await?), + None => None, + }, }) } fn new_visited_module(module: ResolvedVc>, idx: GraphNodeIndex) -> Self { @@ -1039,10 +1069,13 @@ impl Visit for SingleModuleGraphBuilder<'_> { fn visit(&mut self, edge: Self::Edge) -> VisitControlFlow { match edge.to { - SingleModuleGraphBuilderNode::Module { .. } - | SingleModuleGraphBuilderNode::ChunkableReference { .. } => { - VisitControlFlow::Continue(edge.to) - } + SingleModuleGraphBuilderNode::Module { .. } => VisitControlFlow::Continue(edge.to), + SingleModuleGraphBuilderNode::ChunkableReference { + ref chunking_type, .. + } => match chunking_type { + ChunkingType::Traced => VisitControlFlow::Skip(edge.to), + _ => VisitControlFlow::Continue(edge.to), + }, // Module was already visited previously SingleModuleGraphBuilderNode::VisitedModule { .. } => VisitControlFlow::Skip(edge.to), // Issues doen't have any children @@ -1066,7 +1099,7 @@ impl Visit for SingleModuleGraphBuilder<'_> { Ok(match (module, chunkable_ref_target) { (Some(module), None) => { let refs_cell = primary_chunkable_referenced_modules(*module); - let refs = refs_cell.await?; + let refs = refs_cell.await.context(module.ident().to_string().await?)?; // TODO This is currently too slow // let refs_issues = refs_cell // .take_collectibles::>()