Turbopack: scope hoisting

crates/next-core/src/next_client/context.rs

@@ -470,23 +470,25 @@ pub async fn get_client_chunking_context(
     if next_mode.is_development() {
         builder = builder.hot_module_replacement().use_file_source_map_uris();
     } else {
-        builder = builder.chunking_config(
-            Vc::<EcmascriptChunkType>::default().to_resolved().await?,
-            ChunkingConfig {
-                min_chunk_size: 50_000,
-                max_chunk_count_per_group: 40,
-                max_merge_chunk_size: 200_000,
-                ..Default::default()
-            },
-        );
-        builder = builder.chunking_config(
-            Vc::<CssChunkType>::default().to_resolved().await?,
-            ChunkingConfig {
-                max_merge_chunk_size: 100_000,
-                ..Default::default()
-            },
-        );
-        builder = builder.use_content_hashing(ContentHashing::Direct { length: 16 })
+        builder = builder
+            .chunking_config(
+                Vc::<EcmascriptChunkType>::default().to_resolved().await?,
+                ChunkingConfig {
+                    min_chunk_size: 50_000,
+                    max_chunk_count_per_group: 40,
+                    max_merge_chunk_size: 200_000,
+                    ..Default::default()
+                },
+            )
+            .chunking_config(
+                Vc::<CssChunkType>::default().to_resolved().await?,
+                ChunkingConfig {
+                    max_merge_chunk_size: 100_000,
+                    ..Default::default()
+                },
+            )
+            .use_content_hashing(ContentHashing::Direct { length: 16 })
+            .module_merging(true);
     }
 
     Ok(Vc::upcast(builder.build()))

crates/next-core/src/next_client_reference/visit_client_reference.rs

@@ -326,7 +326,7 @@ impl Visit<VisitClientReferenceNode> for VisitClientReference {
 
             let referenced_modules = referenced_modules
                 .iter()
-                .flat_map(|(chunking_type, modules)| match chunking_type {
+                .flat_map(|(chunking_type, _, modules)| match chunking_type {
                     ChunkingType::Traced => None,
                     _ => Some(modules.iter()),
                 })

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

@@ -11,6 +11,7 @@ use turbopack_core::{
     module::Module,
     module_graph::ModuleGraph,
     reference::{ModuleReferences, SingleChunkableModuleReference},
+    resolve::ExportUsage,
 };
 use turbopack_ecmascript::{
     chunk::{
@@ -60,6 +61,7 @@ impl Module for NextDynamicEntryModule {
             SingleChunkableModuleReference::new(
                 Vc::upcast(*self.module),
                 dynamic_ref_description(),
+                ExportUsage::all(),
             )
             .to_resolved()
             .await?,
@@ -102,6 +104,7 @@ impl EcmascriptChunkPlaceable for NextDynamicEntryModule {
             SingleChunkableModuleReference::new(
                 Vc::upcast(*self.module),
                 dynamic_ref_description(),
+                ExportUsage::all(),
             )
             .to_resolved()
             .await?,

crates/next-core/src/next_edge/context.rs

@@ -255,20 +255,22 @@ pub async fn get_edge_chunking_context_with_client_assets(
     .module_id_strategy(module_id_strategy);
 
     if !next_mode.is_development() {
-        builder = builder.chunking_config(
-            Vc::<EcmascriptChunkType>::default().to_resolved().await?,
-            ChunkingConfig {
-                min_chunk_size: 20_000,
-                ..Default::default()
-            },
-        );
-        builder = builder.chunking_config(
-            Vc::<CssChunkType>::default().to_resolved().await?,
-            ChunkingConfig {
-                max_merge_chunk_size: 100_000,
-                ..Default::default()
-            },
-        );
+        builder = builder
+            .chunking_config(
+                Vc::<EcmascriptChunkType>::default().to_resolved().await?,
+                ChunkingConfig {
+                    min_chunk_size: 20_000,
+                    ..Default::default()
+                },
+            )
+            .chunking_config(
+                Vc::<CssChunkType>::default().to_resolved().await?,
+                ChunkingConfig {
+                    max_merge_chunk_size: 100_000,
+                    ..Default::default()
+                },
+            )
+            .module_merging(true);
     }
 
     Ok(Vc::upcast(builder.build()))
@@ -318,20 +320,22 @@ pub async fn get_edge_chunking_context(
     .module_id_strategy(module_id_strategy);
 
     if !next_mode.is_development() {
-        builder = builder.chunking_config(
-            Vc::<EcmascriptChunkType>::default().to_resolved().await?,
-            ChunkingConfig {
-                min_chunk_size: 20_000,
-                ..Default::default()
-            },
-        );
-        builder = builder.chunking_config(
-            Vc::<CssChunkType>::default().to_resolved().await?,
-            ChunkingConfig {
-                max_merge_chunk_size: 100_000,
-                ..Default::default()
-            },
-        );
+        builder = builder
+            .chunking_config(
+                Vc::<EcmascriptChunkType>::default().to_resolved().await?,
+                ChunkingConfig {
+                    min_chunk_size: 20_000,
+                    ..Default::default()
+                },
+            )
+            .chunking_config(
+                Vc::<CssChunkType>::default().to_resolved().await?,
+                ChunkingConfig {
+                    max_merge_chunk_size: 100_000,
+                    ..Default::default()
+                },
+            )
+            .module_merging(true);
     }
 
     Ok(Vc::upcast(builder.build()))

crates/next-core/src/next_server/context.rs

@@ -1027,7 +1027,8 @@ pub async fn get_server_chunking_context_with_client_assets(
         SourceMapsType::None
     })
     .module_id_strategy(module_id_strategy)
-    .file_tracing(next_mode.is_production());
+    .file_tracing(next_mode.is_production())
+    .module_merging(next_mode.is_production());
 
     if next_mode.is_development() {
         builder = builder.use_file_source_map_uris();
@@ -1092,7 +1093,8 @@ pub async fn get_server_chunking_context(
         SourceMapsType::None
     })
     .module_id_strategy(module_id_strategy)
-    .file_tracing(next_mode.is_production());
+    .file_tracing(next_mode.is_production())
+    .module_merging(next_mode.is_production());
 
     if next_mode.is_development() {
         builder = builder.use_file_source_map_uris()

turbopack/crates/turbopack-browser/src/chunking_context.rs

@@ -97,6 +97,11 @@ impl BrowserChunkingContextBuilder {
         self
     }
 
+    pub fn module_merging(mut self, enable_module_merging: bool) -> Self {
+        self.chunking_context.enable_module_merging = enable_module_merging;
+        self
+    }
+
     pub fn asset_base_path(mut self, asset_base_path: ResolvedVc<Option<RcStr>>) -> Self {
         self.chunking_context.asset_base_path = asset_base_path;
         self
@@ -202,6 +207,8 @@ pub struct BrowserChunkingContext {
     enable_hot_module_replacement: bool,
     /// Enable tracing for this chunking
     enable_tracing: bool,
+    /// Enable module merging
+    enable_module_merging: bool,
     /// The environment chunks will be evaluated in.
     environment: ResolvedVc<Environment>,
     /// The kind of runtime to include in the output.
@@ -248,6 +255,7 @@ impl BrowserChunkingContext {
                 asset_base_path: ResolvedVc::cell(None),
                 enable_hot_module_replacement: false,
                 enable_tracing: false,
+                enable_module_merging: false,
                 environment,
                 runtime_type,
                 minify_type: MinifyType::NoMinify,
@@ -510,6 +518,11 @@ impl ChunkingContext for BrowserChunkingContext {
         Vc::cell(self.enable_tracing)
     }
 
+    #[turbo_tasks::function]
+    fn is_module_merging_enabled(&self) -> Vc<bool> {
+        Vc::cell(self.enable_module_merging)
+    }
+
     #[turbo_tasks::function]
     pub fn minify_type(&self) -> Vc<MinifyType> {
         self.minify_type.cell()

turbopack/crates/turbopack-cli/src/build/mod.rs

@@ -343,23 +343,25 @@ async fn build_internal(
             match *node_env.await? {
                 NodeEnv::Development => {}
                 NodeEnv::Production => {
-                    builder = builder.chunking_config(
-                        Vc::<EcmascriptChunkType>::default().to_resolved().await?,
-                        ChunkingConfig {
-                            min_chunk_size: 50_000,
-                            max_chunk_count_per_group: 40,
-                            max_merge_chunk_size: 200_000,
-                            ..Default::default()
-                        },
-                    );
-                    builder = builder.chunking_config(
-                        Vc::<CssChunkType>::default().to_resolved().await?,
-                        ChunkingConfig {
-                            max_merge_chunk_size: 100_000,
-                            ..Default::default()
-                        },
-                    );
-                    builder = builder.use_content_hashing(ContentHashing::Direct { length: 16 })
+                    builder = builder
+                        .chunking_config(
+                            Vc::<EcmascriptChunkType>::default().to_resolved().await?,
+                            ChunkingConfig {
+                                min_chunk_size: 50_000,
+                                max_chunk_count_per_group: 40,
+                                max_merge_chunk_size: 200_000,
+                                ..Default::default()
+                            },
+                        )
+                        .chunking_config(
+                            Vc::<CssChunkType>::default().to_resolved().await?,
+                            ChunkingConfig {
+                                max_merge_chunk_size: 100_000,
+                                ..Default::default()
+                            },
+                        )
+                        .use_content_hashing(ContentHashing::Direct { length: 16 })
+                        .module_merging(true);
                 }
             }
 
@@ -387,22 +389,24 @@ async fn build_internal(
             match *node_env.await? {
                 NodeEnv::Development => {}
                 NodeEnv::Production => {
-                    builder = builder.chunking_config(
-                        Vc::<EcmascriptChunkType>::default().to_resolved().await?,
-                        ChunkingConfig {
-                            min_chunk_size: 20_000,
-                            max_chunk_count_per_group: 100,
-                            max_merge_chunk_size: 100_000,
-                            ..Default::default()
-                        },
-                    );
-                    builder = builder.chunking_config(
-                        Vc::<CssChunkType>::default().to_resolved().await?,
-                        ChunkingConfig {
-                            max_merge_chunk_size: 100_000,
-                            ..Default::default()
-                        },
-                    );
+                    builder = builder
+                        .chunking_config(
+                            Vc::<EcmascriptChunkType>::default().to_resolved().await?,
+                            ChunkingConfig {
+                                min_chunk_size: 20_000,
+                                max_chunk_count_per_group: 100,
+                                max_merge_chunk_size: 100_000,
+                                ..Default::default()
+                            },
+                        )
+                        .chunking_config(
+                            Vc::<CssChunkType>::default().to_resolved().await?,
+                            ChunkingConfig {
+                                max_merge_chunk_size: 100_000,
+                                ..Default::default()
+                            },
+                        )
+                        .module_merging(true);
                 }
             }
 

turbopack/crates/turbopack-core/src/chunk/chunk_group.rs

@@ -1,8 +1,8 @@
-use std::collections::HashSet;
+use std::{collections::HashSet, sync::atomic::AtomicBool};
 
 use anyhow::{Context, Result};
 use rustc_hash::FxHashMap;
-use turbo_tasks::{FxIndexSet, ResolvedVc, TryJoinIterExt, Value, Vc};
+use turbo_tasks::{FxIndexSet, ResolvedVc, TryFlatJoinIterExt, TryJoinIterExt, Value, Vc};
 
 use super::{
     Chunk, ChunkGroupContent, ChunkItem, ChunkItemWithAsyncModuleInfo, ChunkingContext,
@@ -45,6 +45,7 @@ pub async fn make_chunk_group(
         ChunkLoading::Edge
     );
     let should_trace = *chunking_context.is_tracing_enabled().await?;
+    let should_merge_modules = *chunking_context.is_module_merging_enabled().await?;
     let batching_config = chunking_context.batching_config();
 
     let ChunkGroupContent {
@@ -58,6 +59,7 @@ pub async fn make_chunk_group(
         availability_info,
         can_split_async,
         should_trace,
+        should_merge_modules,
         batching_config,
     )
     .await?;
@@ -189,6 +191,7 @@ pub async fn chunk_group_content(
     availability_info: AvailabilityInfo,
     can_split_async: bool,
     should_trace: bool,
+    should_merge_modules: bool,
     batching_config: Vc<BatchingConfig>,
 ) -> Result<ChunkGroupContent> {
     let module_batches_graph = module_graph.module_batches(batching_config).await?;
@@ -315,6 +318,67 @@ pub async fn chunk_group_content(
         },
     )?;
 
+    if should_merge_modules {
+        let merged_modules = module_graph.merged_modules().await?;
+        state.chunkable_items = state
+            .chunkable_items
+            .into_iter()
+            .map(async |chunkable_module| match chunkable_module {
+                ChunkableModuleOrBatch::Module(module) => {
+                    if !merged_modules.should_create_chunk_item_for(ResolvedVc::upcast(module)) {
+                        return Ok(vec![]);
+                    }
+
+                    Ok(vec![ChunkableModuleOrBatch::Module(
+                        merged_modules
+                            .should_replace_module(ResolvedVc::upcast(module))
+                            .unwrap_or(module),
+                    )])
+                }
+                ChunkableModuleOrBatch::Batch(batch) => {
+                    let batch_ref = batch.await?;
+                    let modules = &batch_ref.modules;
+
+                    let modified = AtomicBool::new(false);
+                    let modules = modules
+                        .iter()
+                        .filter(|module| {
+                            if merged_modules
+                                .should_create_chunk_item_for(ResolvedVc::upcast(**module))
+                            {
+                                true
+                            } else {
+                                modified.store(true, std::sync::atomic::Ordering::Release);
+                                false
+                            }
+                        })
+                        .map(|&module| {
+                            if let Some(module) =
+                                merged_modules.should_replace_module(ResolvedVc::upcast(module))
+                            {
+                                modified.store(true, std::sync::atomic::Ordering::Release);
+                                module
+                            } else {
+                                module
+                            }
+                        })
+                        .map(ChunkableModuleOrBatch::Module)
+                        .collect::<Vec<_>>();
+
+                    if modified.load(std::sync::atomic::Ordering::Acquire) {
+                        Ok(modules)
+                    } else {
+                        Ok(vec![ChunkableModuleOrBatch::Batch(batch)])
+                    }
+                }
+                ChunkableModuleOrBatch::None(i) => Ok(vec![ChunkableModuleOrBatch::None(i)]),
+            })
+            .try_flat_join()
+            .await?
+            .into_iter()
+            .collect();
+    }
+
     let mut batch_groups = FxIndexSet::default();
     for &module in &state.chunkable_items {
         if let Some(batch_group) = module_batches_graph.get_batch_group(&module.into()) {