Scope hoist tree shaking module types as well

mischnic · mischnic · commit 9668380f202f · 2025-06-17T12:22:17.000+02:00
diff --git a/turbopack/crates/turbopack-ecmascript/src/lib.rs b/turbopack/crates/turbopack-ecmascript/src/lib.rs
@@ -971,7 +971,7 @@ impl EcmascriptModuleContentOptions {
 
             let part_code_gens = part_references
                 .iter()
-                .map(|r| r.code_generation(**chunking_context))
+                .map(|r| r.code_generation(**chunking_context, scope_hoisting_context))
                 .try_join()
                 .await?;
 
diff --git a/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs b/turbopack/crates/turbopack-ecmascript/src/references/esm/base.rs
@@ -544,8 +544,9 @@ impl EsmAssetReference {
                             .as_ref()
                             .is_none_or(|e| matches!(e, ModulePart::Exports))
                     {
-                        // No need to import, the module is already available in the same scope
-                        // hoisting group (unless it's a namespace import)
+                        // No need to import, the module was already executed and is available in
+                        // the same scope hoisting group (unless it's a
+                        // namespace import)
                     } else if let Some(ident) = referenced_asset
                         .get_ident(chunking_context, None, scope_hoisting_context)
                         .await?
diff --git a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/facade/module.rs b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/facade/module.rs
@@ -1,12 +1,15 @@
 use std::collections::BTreeMap;
 
-use anyhow::{Result, bail};
+use anyhow::{Context, Result, bail};
 use turbo_rcstr::rcstr;
 use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::{File, FileContent, glob::Glob};
 use turbopack_core::{
     asset::{Asset, AssetContent},
-    chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext, EvaluatableAsset},
+    chunk::{
+        AsyncModuleInfo, ChunkableModule, ChunkingContext, EvaluatableAsset, MergeableModule,
+        MergeableModules, MergeableModulesExposed,
+    },
     ident::AssetIdent,
     module::Module,
     module_graph::ModuleGraph,
@@ -17,7 +20,7 @@ use turbopack_core::{
 use super::chunk_item::EcmascriptModuleFacadeChunkItem;
 use crate::{
     AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptModuleContent,
-    EcmascriptModuleContentOptions, SpecifiedModuleType,
+    EcmascriptModuleContentOptions, EcmascriptOptions, MergedEcmascriptModule, SpecifiedModuleType,
     chunk::{EcmascriptChunkPlaceable, EcmascriptExports},
     code_gen::CodeGens,
     parse::ParseResult,
@@ -450,3 +453,36 @@ impl ChunkableModule for EcmascriptModuleFacadeModule {
 
 #[turbo_tasks::value_impl]
 impl EvaluatableAsset for EcmascriptModuleFacadeModule {}
+
+#[turbo_tasks::value_impl]
+impl MergeableModule for EcmascriptModuleFacadeModule {
+    #[turbo_tasks::function]
+    async fn merge(
+        self: Vc<Self>,
+        modules: Vc<MergeableModulesExposed>,
+        entry_points: Vc<MergeableModules>,
+    ) -> Result<Vc<Box<dyn ChunkableModule>>> {
+        Ok(Vc::upcast(*MergedEcmascriptModule::new(
+            modules
+                .await?
+                .iter()
+                .map(|(m, exposed)| {
+                    Ok((
+                        ResolvedVc::try_sidecast::<Box<dyn EcmascriptAnalyzable>>(*m)
+                            .context("expected EcmascriptAnalyzable")?,
+                        *exposed,
+                    ))
+                })
+                .collect::<Result<Vec<_>>>()?,
+            entry_points
+                .await?
+                .iter()
+                .map(|m| {
+                    ResolvedVc::try_sidecast::<Box<dyn EcmascriptAnalyzable>>(*m)
+                        .context("expected EcmascriptAnalyzable")
+                })
+                .collect::<Result<Vec<_>>>()?,
+            EcmascriptOptions::default().resolved_cell(),
+        )))
+    }
+}
diff --git a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/module.rs b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/locals/module.rs
@@ -1,11 +1,14 @@
 use std::collections::BTreeMap;
 
-use anyhow::{Result, bail};
+use anyhow::{Context, Result, bail};
 use turbo_tasks::{ResolvedVc, Vc};
 use turbo_tasks_fs::glob::Glob;
 use turbopack_core::{
     asset::{Asset, AssetContent},
-    chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext},
+    chunk::{
+        AsyncModuleInfo, ChunkableModule, ChunkingContext, MergeableModule, MergeableModules,
+        MergeableModulesExposed,
+    },
     ident::AssetIdent,
     module::Module,
     module_graph::ModuleGraph,
@@ -16,7 +19,7 @@ use turbopack_core::{
 use super::chunk_item::EcmascriptModuleLocalsChunkItem;
 use crate::{
     AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptModuleAsset,
-    EcmascriptModuleContent, EcmascriptModuleContentOptions,
+    EcmascriptModuleContent, EcmascriptModuleContentOptions, MergedEcmascriptModule,
     chunk::{EcmascriptChunkPlaceable, EcmascriptExports},
     references::{
         async_module::OptionAsyncModule,
@@ -205,3 +208,36 @@ impl ChunkableModule for EcmascriptModuleLocalsModule {
         )
     }
 }
+
+#[turbo_tasks::value_impl]
+impl MergeableModule for EcmascriptModuleLocalsModule {
+    #[turbo_tasks::function]
+    async fn merge(
+        &self,
+        modules: Vc<MergeableModulesExposed>,
+        entry_points: Vc<MergeableModules>,
+    ) -> Result<Vc<Box<dyn ChunkableModule>>> {
+        Ok(Vc::upcast(*MergedEcmascriptModule::new(
+            modules
+                .await?
+                .iter()
+                .map(|(m, exposed)| {
+                    Ok((
+                        ResolvedVc::try_sidecast::<Box<dyn EcmascriptAnalyzable>>(*m)
+                            .context("expected EcmascriptAnalyzable")?,
+                        *exposed,
+                    ))
+                })
+                .collect::<Result<Vec<_>>>()?,
+            entry_points
+                .await?
+                .iter()
+                .map(|m| {
+                    ResolvedVc::try_sidecast::<Box<dyn EcmascriptAnalyzable>>(*m)
+                        .context("expected EcmascriptAnalyzable")
+                })
+                .collect::<Result<Vec<_>>>()?,
+            self.module.await?.options,
+        )))
+    }
+}
diff --git a/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/reference.rs b/turbopack/crates/turbopack-ecmascript/src/side_effect_optimization/reference.rs
@@ -1,6 +1,6 @@
 use anyhow::{Context, Result, bail};
 use serde::{Deserialize, Serialize};
-use swc_core::{common::DUMMY_SP, quote};
+use swc_core::{common::DUMMY_SP, ecma::ast::Lit, quote};
 use turbo_rcstr::RcStr;
 use turbo_tasks::{NonLocalValue, ResolvedVc, ValueToString, Vc, trace::TraceRawVcs};
 use turbopack_core::{
@@ -17,8 +17,11 @@ use super::{
     facade::module::EcmascriptModuleFacadeModule, locals::module::EcmascriptModuleLocalsModule,
 };
 use crate::{
-    ScopeHoistingContext, chunk::EcmascriptChunkPlaceable, code_gen::CodeGeneration,
-    references::esm::base::ReferencedAsset, runtime_functions::TURBOPACK_IMPORT,
+    ScopeHoistingContext,
+    chunk::EcmascriptChunkPlaceable,
+    code_gen::{CodeGeneration, CodeGenerationHoistedStmt},
+    references::esm::base::ReferencedAsset,
+    runtime_functions::TURBOPACK_IMPORT,
     utils::module_id_to_lit,
 };
 
@@ -152,29 +155,65 @@ impl EcmascriptModulePartReference {
     pub async fn code_generation(
         self: Vc<Self>,
         chunking_context: Vc<Box<dyn ChunkingContext>>,
+        scope_hoisting_context: ScopeHoistingContext<'_>,
     ) -> Result<CodeGeneration> {
         let referenced_asset = ReferencedAsset::from_resolve_result(self.resolve_reference());
         let referenced_asset = referenced_asset.await?;
-        let ident = referenced_asset
-            .get_ident(chunking_context, None, ScopeHoistingContext::None)
-            .await?
-            .context("part module reference should have an ident")?
-            .as_expr_individual(DUMMY_SP)
-            .unwrap_left();
+        let part = &self.await?.part;
 
         let ReferencedAsset::Some(module) = *referenced_asset else {
             bail!("part module reference should have an module reference");
         };
-        let id = module.chunk_item_id(Vc::upcast(chunking_context)).await?;
-
-        Ok(CodeGeneration::hoisted_stmt(
-            ident.sym.as_str().into(),
-            quote!(
-                "var $name = $turbopack_import($id);" as Stmt,
-                name = ident,
-                turbopack_import: Expr = TURBOPACK_IMPORT.into(),
-                id: Expr = module_id_to_lit(&id),
-            ),
-        ))
+
+        let mut result = vec![];
+
+        let merged_index = scope_hoisting_context.get_module_index(module);
+        if let Some(merged_index) = merged_index {
+            // Insert a placeholder to inline the merged module at the right place
+            // relative to the other references (so to keep reference order).
+            result.push(CodeGenerationHoistedStmt::new(
+                format!("hoisted {merged_index}").into(),
+                quote!(
+                    "__turbopack_merged_esm__($id);" as Stmt,
+                    id: Expr = Lit::Num(merged_index.into()).into(),
+                ),
+            ));
+        }
+
+        let needs_namespace = match part {
+            ModulePart::Export(_) | ModulePart::RenamedExport { .. } | ModulePart::Evaluation => {
+                false
+            }
+            ModulePart::RenamedNamespace { .. }
+            | ModulePart::Internal(_)
+            | ModulePart::Locals
+            | ModulePart::Exports
+            | ModulePart::Facade => true,
+        };
+
+        if merged_index.is_some() && !needs_namespace {
+            // No need to import, the module was already executed and is available in the same scope
+            // hoisting group (unless it's a namespace import)
+        } else {
+            let ident = referenced_asset
+                .get_ident(chunking_context, None, scope_hoisting_context)
+                .await?
+                .context("part module reference should have an ident")?
+                .as_expr_individual(DUMMY_SP)
+                .unwrap_left();
+            let id = module.chunk_item_id(Vc::upcast(chunking_context)).await?;
+
+            result.push(CodeGenerationHoistedStmt::new(
+                ident.sym.as_str().into(),
+                quote!(
+                    "var $name = $turbopack_import($id);" as Stmt,
+                    name = ident,
+                    turbopack_import: Expr = TURBOPACK_IMPORT.into(),
+                    id: Expr = module_id_to_lit(&id),
+                ),
+            ));
+        }
+
+        Ok(CodeGeneration::hoisted_stmts(result))
     }
 }
