Unverified Commit ad030d78 authored by Tobias Koppers's avatar Tobias Koppers Committed by GitHub

Turbopack: Tree shaking fixes and code organization (#89295)

## Summary

A series of bug fixes, refactors, and code organization improvements to Turbopack's tree shaking and side effect optimization:

- **Fix `ModulePart` handling for `FreeVarReference::EcmaScriptModule`** — pass `ModulePart` correctly so free variable references resolve to the right module part
- **Extract `EcmascriptModuleRenameModule`** — split the rename/reexport logic (`RenamedExport`, `RenamedNamespace`) out of `EcmascriptModuleFacadeModule` into a dedicated `rename` module, shared between side effects optimization and tree shaking
- **Simplify `EcmascriptModuleFacadeModule`** — now only handles the `Facade` case (locals + reexports), no longer overloaded with rename variants
- **Reorganize tree shaking code** — moved `asset.rs` → `part/module.rs`, `chunk_item.rs` → `part/chunk_item.rs` + `side_effects/chunk_item.rs`, `side_effect_module.rs` → `side_effects/module.rs` for clearer separation between part modules and side effect modules
- **Use `EsmExport` in `FindExportFromReexportsResult`** — reduces code duplication by reusing the existing `EsmExport` enum
- **Minor simplifications** — code deduplication, reordered checks, and general cleanup
parent 286a73f8
......@@ -42,7 +42,7 @@ use turbopack_core::{
};
use turbopack_ecmascript::{
EcmascriptParsable, chunk::EcmascriptChunkPlaceable, parse::ParseResult,
tree_shake::asset::EcmascriptModulePartAsset,
tree_shake::part::module::EcmascriptModulePartAsset,
};
/// Metadata for a server action: (layer, exported_name, filename)
......
......@@ -40,6 +40,20 @@ fn dynamic_ref_description() -> RcStr {
rcstr!("next/dynamic reference")
}
impl NextDynamicEntryModule {
async fn module_reference(&self) -> Result<ResolvedVc<Box<dyn ModuleReference>>> {
Ok(ResolvedVc::upcast(
SingleChunkableModuleReference::new(
Vc::upcast(*self.module),
dynamic_ref_description(),
ExportUsage::all(),
)
.to_resolved()
.await?,
))
}
}
#[turbo_tasks::value_impl]
impl Module for NextDynamicEntryModule {
#[turbo_tasks::function]
......@@ -56,15 +70,7 @@ impl Module for NextDynamicEntryModule {
#[turbo_tasks::function]
async fn references(&self) -> Result<Vc<ModuleReferences>> {
Ok(Vc::cell(vec![ResolvedVc::upcast(
SingleChunkableModuleReference::new(
Vc::upcast(*self.module),
dynamic_ref_description(),
ExportUsage::all(),
)
.to_resolved()
.await?,
)]))
Ok(Vc::cell(vec![self.module_reference().await?]))
}
#[turbo_tasks::function]
fn side_effects(self: Vc<Self>) -> Vc<ModuleSideEffects> {
......
......@@ -61,6 +61,16 @@ impl NextServerComponentModule {
}
}
impl NextServerComponentModule {
async fn module_reference(&self) -> Result<ResolvedVc<Box<dyn ModuleReference>>> {
Ok(ResolvedVc::upcast(
NextServerComponentModuleReference::new(Vc::upcast(*self.module))
.to_resolved()
.await?,
))
}
}
#[turbo_tasks::value_impl]
impl Module for NextServerComponentModule {
#[turbo_tasks::function]
......@@ -77,11 +87,7 @@ impl Module for NextServerComponentModule {
#[turbo_tasks::function]
async fn references(&self) -> Result<Vc<ModuleReferences>> {
Ok(Vc::cell(vec![ResolvedVc::upcast(
NextServerComponentModuleReference::new(Vc::upcast(*self.module))
.to_resolved()
.await?,
)]))
Ok(Vc::cell(vec![self.module_reference().await?]))
}
#[turbo_tasks::function]
fn side_effects(self: Vc<Self>) -> Vc<ModuleSideEffects> {
......
......@@ -41,6 +41,16 @@ impl NextServerUtilityModule {
}
}
impl NextServerUtilityModule {
async fn module_reference(&self) -> Result<ResolvedVc<Box<dyn ModuleReference>>> {
Ok(ResolvedVc::upcast(
NextServerUtilityModuleReference::new(Vc::upcast(*self.module))
.to_resolved()
.await?,
))
}
}
#[turbo_tasks::value_impl]
impl Module for NextServerUtilityModule {
#[turbo_tasks::function]
......@@ -57,11 +67,7 @@ impl Module for NextServerUtilityModule {
#[turbo_tasks::function]
async fn references(&self) -> Result<Vc<ModuleReferences>> {
Ok(Vc::cell(vec![ResolvedVc::upcast(
NextServerUtilityModuleReference::new(Vc::upcast(*self.module))
.to_resolved()
.await?,
)]))
Ok(Vc::cell(vec![self.module_reference().await?]))
}
#[turbo_tasks::function]
......
......@@ -23,6 +23,7 @@ pub mod minify;
pub mod parse;
mod path_visitor;
pub mod references;
pub mod rename;
pub mod runtime_functions;
pub mod side_effect_optimization;
pub mod single_file_ecmascript_output;
......@@ -95,7 +96,7 @@ use turbopack_core::{
reference::ModuleReferences,
reference_type::InnerAssets,
resolve::{
FindContextFileResult, ModulePart, find_context_file, origin::ResolveOrigin, package_json,
FindContextFileResult, find_context_file, origin::ResolveOrigin, package_json,
parse::Request,
},
source::Source,
......@@ -118,10 +119,7 @@ use crate::{
async_module::OptionAsyncModule,
esm::{UrlRewriteBehavior, base::EsmAssetReferences, export},
},
side_effect_optimization::{
facade::module::EcmascriptModuleFacadeModule, locals::module::EcmascriptModuleLocalsModule,
reference::EcmascriptModulePartReference,
},
side_effect_optimization::reference::EcmascriptModulePartReference,
swc_comments::{CowComments, ImmutableComments},
transform::{remove_directives, remove_shebang},
};
......@@ -832,44 +830,6 @@ impl EcmascriptChunkPlaceable for EcmascriptModuleAsset {
}
}
#[turbo_tasks::value_impl]
impl EcmascriptModuleAsset {
/// Returns the locals module if the module should be split (has re-exports), otherwise self.
///
/// The locals module contains only the local bindings and evaluation side effects,
/// while re-exports are handled separately by the facade module.
#[turbo_tasks::function]
pub async fn get_locals_if_split(
self: Vc<Self>,
) -> Result<Vc<Box<dyn EcmascriptChunkPlaceable>>> {
let should_split = *self.get_exports().split_locals_and_reexports().await?;
Ok(if should_split {
Vc::upcast(EcmascriptModuleLocalsModule::new(self))
} else {
Vc::upcast(self)
})
}
/// Returns the facade module if the module should be split (has re-exports), otherwise self.
///
/// The facade module re-exports all exports from the original module, including
/// both local bindings (via the locals module) and re-exports from other modules.
#[turbo_tasks::function]
pub async fn get_facade_if_split(
self: Vc<Self>,
) -> Result<Vc<Box<dyn EcmascriptChunkPlaceable>>> {
let should_split = *self.get_exports().split_locals_and_reexports().await?;
Ok(if should_split {
Vc::upcast(EcmascriptModuleFacadeModule::new(
Vc::upcast(self),
ModulePart::Facade,
))
} else {
Vc::upcast(self)
})
}
}
#[turbo_tasks::value_impl]
impl MergeableModule for EcmascriptModuleAsset {
#[turbo_tasks::function]
......
......@@ -49,7 +49,7 @@ use crate::{
util::throw_module_not_found_expr,
},
runtime_functions::{TURBOPACK_EXTERNAL_IMPORT, TURBOPACK_EXTERNAL_REQUIRE, TURBOPACK_IMPORT},
tree_shake::{TURBOPACK_PART_IMPORT_SOURCE, asset::EcmascriptModulePartAsset},
tree_shake::{TURBOPACK_PART_IMPORT_SOURCE, part::module::EcmascriptModulePartAsset},
utils::module_id_to_lit,
};
......
......@@ -2,6 +2,7 @@ use std::{borrow::Cow, collections::BTreeMap, ops::ControlFlow};
use anyhow::{Result, bail};
use bincode::{Decode, Encode};
use indexmap::map::Entry;
use rustc_hash::FxHashSet;
use swc_core::{
common::{DUMMY_SP, SyntaxContext},
......@@ -32,7 +33,7 @@ use crate::{
magic_identifier,
references::esm::base::ReferencedAsset,
runtime_functions::{TURBOPACK_DYNAMIC, TURBOPACK_ESM},
tree_shake::asset::EcmascriptModulePartAsset,
tree_shake::part::module::EcmascriptModulePartAsset,
utils::module_id_to_lit,
};
......@@ -157,15 +158,6 @@ pub async fn follow_reexports(
let mut module = module;
let mut export_name = export_name;
loop {
let exports = module.get_exports().await?;
let EcmascriptExports::EsmExports(exports) = &*exports else {
return Ok(FollowExportsResult::cell(FollowExportsResult {
module,
export_name: Some(export_name),
ty: FoundExportType::Dynamic,
}));
};
if !ignore_side_effects
&& *module.side_effects().await? != ModuleSideEffects::SideEffectFree
{
......@@ -180,6 +172,15 @@ pub async fn follow_reexports(
}
ignore_side_effects = false;
let exports = module.get_exports().await?;
let EcmascriptExports::EsmExports(exports) = &*exports else {
return Ok(FollowExportsResult::cell(FollowExportsResult {
module,
export_name: Some(export_name),
ty: FoundExportType::Dynamic,
}));
};
// Try to find the export in the local exports
let exports_ref = exports.await?;
if let Some(export) = exports_ref.exports.get(&export_name) {
......@@ -198,30 +199,44 @@ pub async fn follow_reexports(
// Try to find the export in the star exports
if !exports_ref.star_exports.is_empty() && &*export_name != "default" {
let result = find_export_from_reexports(*module, export_name.clone()).await?;
if let Some(m) = result.esm_export {
module = m;
continue;
}
return match &result.dynamic_exporting_modules[..] {
[] => Ok(FollowExportsResult {
module,
export_name: Some(export_name),
ty: FoundExportType::NotFound,
match &*result {
FindExportFromReexportsResult::NotFound => {
return Ok(FollowExportsResult::cell(FollowExportsResult {
module,
export_name: Some(export_name),
ty: FoundExportType::NotFound,
}));
}
.cell()),
[module] => Ok(FollowExportsResult {
module: *module,
export_name: Some(export_name),
ty: FoundExportType::Dynamic,
FindExportFromReexportsResult::EsmExport(esm_export) => {
match handle_declared_export(module, export_name, esm_export).await? {
ControlFlow::Continue((m, n)) => {
module = m.to_resolved().await?;
export_name = n;
continue;
}
ControlFlow::Break(result) => {
return Ok(result.cell());
}
}
}
.cell()),
_ => Ok(FollowExportsResult {
module,
export_name: Some(export_name),
ty: FoundExportType::Dynamic,
FindExportFromReexportsResult::Dynamic(dynamic_exporting_modules) => {
return match &dynamic_exporting_modules[..] {
[] => unreachable!(),
[module] => Ok(FollowExportsResult {
module: *module,
export_name: Some(export_name),
ty: FoundExportType::Dynamic,
}
.cell()),
_ => Ok(FollowExportsResult {
module,
export_name: Some(export_name),
ty: FoundExportType::Dynamic,
}
.cell()),
};
}
.cell()),
};
}
}
return Ok(FollowExportsResult::cell(FollowExportsResult {
......@@ -279,9 +294,10 @@ async fn handle_declared_export(
}
#[turbo_tasks::value]
struct FindExportFromReexportsResult {
esm_export: Option<ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>>,
dynamic_exporting_modules: Vec<ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>>,
enum FindExportFromReexportsResult {
NotFound,
EsmExport(EsmExport),
Dynamic(Vec<ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>>),
}
#[turbo_tasks::function]
......@@ -310,18 +326,26 @@ async fn find_export_from_reexports(
}
let all_export_names = get_all_export_names(*module).await?;
let esm_export = all_export_names.esm_exports.get(&export_name).copied();
Ok(FindExportFromReexportsResult {
esm_export,
dynamic_exporting_modules: all_export_names.dynamic_exporting_modules.clone(),
}
.cell())
Ok(
if let Some(esm_export) = all_export_names.esm_exports.get(&export_name) {
FindExportFromReexportsResult::EsmExport(esm_export.clone())
} else if all_export_names.dynamic_exporting_modules.is_empty() {
FindExportFromReexportsResult::NotFound
} else {
FindExportFromReexportsResult::Dynamic(
all_export_names.dynamic_exporting_modules.clone(),
)
}
.cell(),
)
}
#[turbo_tasks::value]
struct AllExportNamesResult {
/// A map from export name to how each export is defined.
#[bincode(with = "turbo_bincode::indexmap")]
esm_exports: FxIndexMap<RcStr, ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>>,
esm_exports: FxIndexMap<RcStr, EsmExport>,
/// A list of all direct or indirectly referenced modules that are dynamically exporting
dynamic_exporting_modules: Vec<ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>>,
}
......@@ -341,7 +365,12 @@ async fn get_all_export_names(
let exports = exports.await?;
let mut esm_exports = FxIndexMap::default();
let mut dynamic_exporting_modules = Vec::new();
esm_exports.extend(exports.exports.keys().cloned().map(|n| (n, module)));
esm_exports.extend(
exports
.exports
.iter()
.map(|(name, esm_export)| (name.clone(), esm_export.clone())),
);
let star_export_names = exports
.star_exports
.iter()
......@@ -350,7 +379,7 @@ async fn get_all_export_names(
if let ReferencedAsset::Some(m) =
*ReferencedAsset::from_resolve_result(esm_ref.resolve_reference()).await?
{
Some(expand_star_exports(*m))
Some(expand_star_exports(**esm_ref, *m))
} else {
None
},
......@@ -364,7 +393,7 @@ async fn get_all_export_names(
star_export_names
.esm_exports
.iter()
.map(|(k, &v)| (k.clone(), v)),
.map(|(k, v)| (k.clone(), v.clone())),
);
dynamic_exporting_modules
.extend(star_export_names.dynamic_exporting_modules.iter().copied());
......@@ -380,35 +409,45 @@ async fn get_all_export_names(
#[turbo_tasks::value]
pub struct ExpandStarResult {
#[bincode(with = "turbo_bincode::indexmap")]
pub esm_exports: FxIndexMap<RcStr, ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>>,
pub esm_exports: FxIndexMap<RcStr, EsmExport>,
pub dynamic_exporting_modules: Vec<ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>>,
}
#[turbo_tasks::function]
pub async fn expand_star_exports(
root_reference: ResolvedVc<Box<dyn ModuleReference>>,
root_module: ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>,
) -> Result<Vc<ExpandStarResult>> {
let mut esm_exports = FxIndexMap::default();
let mut dynamic_exporting_modules = Vec::new();
let mut checked_modules = FxHashSet::default();
checked_modules.insert(root_module);
let mut queue = vec![(root_module, root_module.get_exports())];
while let Some((asset, exports)) = queue.pop() {
let mut queue = vec![(root_reference, root_module, root_module.get_exports())];
while let Some((reference, asset, exports)) = queue.pop() {
match &*exports.await? {
EcmascriptExports::EsmExports(exports) => {
let exports = exports.await?;
for key in exports.exports.keys() {
for (key, esm_export) in exports.exports.iter() {
if key == "default" {
continue;
}
esm_exports.entry(key.clone()).or_insert(asset);
if let Entry::Vacant(entry) = esm_exports.entry(key.clone()) {
entry.insert(match esm_export {
EsmExport::LocalBinding(_, liveness) => EsmExport::ImportedBinding(
reference,
key.clone(),
*liveness == Liveness::Mutable,
),
_ => esm_export.clone(),
});
}
}
for esm_ref in exports.star_exports.iter() {
if let ReferencedAsset::Some(asset) =
&*ReferencedAsset::from_resolve_result(esm_ref.resolve_reference()).await?
&& checked_modules.insert(*asset)
{
queue.push((*asset, asset.get_exports()));
queue.push((*esm_ref, *asset, asset.get_exports()));
}
}
}
......@@ -559,7 +598,7 @@ impl EsmExports {
continue;
};
let export_info = expand_star_exports(**asset).await?;
let export_info = expand_star_exports(*esm_ref, **asset).await?;
for export in export_info.esm_exports.keys() {
if export == "default" {
......
......@@ -3087,12 +3087,7 @@ async fn handle_free_var_reference(
span.hi.to_u32(),
),
Default::default(),
match state.tree_shaking_mode {
Some(
TreeShakingMode::ModuleFragments | TreeShakingMode::ReexportsOnly,
) => export.clone().map(ModulePart::export),
None => None,
},
export.clone().map(ModulePart::export),
ImportUsage::TopLevel,
state.import_externals,
state.tree_shaking_mode,
......
use std::collections::BTreeMap;
use anyhow::{Result, bail};
use turbo_tasks::{ResolvedVc, Vc};
use turbo_tasks_fs::{File, FileContent};
use turbopack_core::{
asset::{Asset, AssetContent},
chunk::{
AsyncModuleInfo, ChunkableModule, ChunkingContext, EvaluatableAsset, MergeableModule,
MergeableModules, MergeableModulesExposed,
},
ident::AssetIdent,
module::{Module, ModuleSideEffects},
module_graph::ModuleGraph,
reference::ModuleReferences,
resolve::{ExportUsage, ModulePart},
source::OptionSource,
};
use crate::{
AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptAnalyzableExt,
EcmascriptModuleContent, EcmascriptModuleContentOptions, EcmascriptOptions,
MergedEcmascriptModule, SpecifiedModuleType,
chunk::{
EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptExports,
ecmascript_chunk_item,
},
code_gen::CodeGens,
references::{
async_module::{AsyncModule, OptionAsyncModule},
esm::{EsmExport, EsmExports, base::EsmAssetReferences},
},
side_effect_optimization::reference::EcmascriptModulePartReference,
};
/// A module derived from an original ecmascript module that reexports a single export or the whole
/// namespace object under a different name.
#[turbo_tasks::value]
pub struct EcmascriptModuleRenameModule {
module: ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>,
/// The part of the module that this facade represents.
/// ModulePart::Facade | ModulePart::RenamedExport |
/// ModulePart::RenamedNamespace
part: ModulePart,
}
#[turbo_tasks::value_impl]
impl EcmascriptModuleRenameModule {
#[turbo_tasks::function]
pub fn new(
module: ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>,
part: ModulePart,
) -> Vc<Self> {
assert!(
matches!(
part,
ModulePart::RenamedExport { .. } | ModulePart::RenamedNamespace { .. }
),
"{part:?} is unexpected for EcmascriptModuleRenameModule"
);
EcmascriptModuleRenameModule { module, part }.cell()
}
#[turbo_tasks::function]
pub async fn async_module(&self) -> Result<Vc<AsyncModule>> {
let (import_externals, has_top_level_await) =
if let Some(async_module) = *self.module.get_async_module().await? {
(
async_module.await?.import_externals,
async_module.await?.has_top_level_await,
)
} else {
(false, false)
};
Ok(AsyncModule {
has_top_level_await,
import_externals,
}
.cell())
}
}
impl EcmascriptModuleRenameModule {
pub async fn module_reference(&self) -> Result<ResolvedVc<EcmascriptModulePartReference>> {
match &self.part {
ModulePart::RenamedNamespace { .. } => {
EcmascriptModulePartReference::new_normal(
*self.module,
self.part.clone(),
ExportUsage::all(),
)
.to_resolved()
.await
}
ModulePart::RenamedExport {
original_export, ..
} => {
EcmascriptModulePartReference::new_normal(
*self.module,
self.part.clone(),
ExportUsage::named(original_export.clone()),
)
.to_resolved()
.await
}
_ => {
bail!("Unexpected ModulePart for EcmascriptModuleRenameModule");
}
}
}
}
#[turbo_tasks::value_impl]
impl Module for EcmascriptModuleRenameModule {
#[turbo_tasks::function]
fn source(&self) -> Vc<OptionSource> {
Vc::cell(None)
}
#[turbo_tasks::function]
fn ident(&self) -> Vc<AssetIdent> {
self.module.ident().with_part(self.part.clone())
}
#[turbo_tasks::function]
async fn references(self: Vc<Self>) -> Result<Vc<ModuleReferences>> {
let reference = self.await?.module_reference().await?;
Ok(Vc::cell(vec![ResolvedVc::upcast(reference)]))
}
#[turbo_tasks::function]
async fn is_self_async(self: Vc<Self>) -> Result<Vc<bool>> {
let async_module = self.async_module();
let references = self.references();
let is_self_async = async_module
.resolve()
.await?
.is_self_async(references.resolve().await?)
.resolve()
.await?;
Ok(is_self_async)
}
#[turbo_tasks::function]
fn side_effects(&self) -> Vc<ModuleSideEffects> {
// This just re-exports another import
ModuleSideEffects::ModuleEvaluationIsSideEffectFree.cell()
}
}
#[turbo_tasks::value_impl]
impl Asset for EcmascriptModuleRenameModule {
#[turbo_tasks::function]
fn content(&self) -> Vc<AssetContent> {
let f = File::from("");
AssetContent::file(FileContent::Content(f).cell())
}
}
#[turbo_tasks::value_impl]
impl EcmascriptAnalyzable for EcmascriptModuleRenameModule {
#[turbo_tasks::function]
fn analyze(&self) -> Result<Vc<AnalyzeEcmascriptModuleResult>> {
bail!("EcmascriptModuleRenameModule::analyze shouldn't be called");
}
#[turbo_tasks::function]
fn module_content_without_analysis(
&self,
_generate_source_map: bool,
) -> Result<Vc<EcmascriptModuleContent>> {
bail!("EcmascriptModuleRenameModule::module_content_without_analysis shouldn't be called");
}
#[turbo_tasks::function]
async fn module_content_options(
self: ResolvedVc<Self>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
async_module_info: Option<ResolvedVc<AsyncModuleInfo>>,
) -> Result<Vc<EcmascriptModuleContentOptions>> {
let reference = self.await?.module_reference().await?;
Ok(EcmascriptModuleContentOptions {
parsed: None,
module: ResolvedVc::upcast(self),
specified_module_type: SpecifiedModuleType::EcmaScript,
chunking_context,
references: self.references().to_resolved().await?,
part_references: vec![reference],
esm_references: EsmAssetReferences::empty().to_resolved().await?,
code_generation: CodeGens::empty().to_resolved().await?,
async_module: ResolvedVc::cell(Some(self.async_module().to_resolved().await?)),
// The facade module cannot generate source maps, because the inserted references
// contain spans from the original module, but the facade module itself doesn't have the
// original module's swc_common::SourceMap in `parsed`.
generate_source_map: false,
original_source_map: None,
exports: self.get_exports().to_resolved().await?,
async_module_info,
}
.cell())
}
}
#[turbo_tasks::value_impl]
impl EcmascriptChunkPlaceable for EcmascriptModuleRenameModule {
#[turbo_tasks::function]
async fn get_exports(&self) -> Result<Vc<EcmascriptExports>> {
let reference = self.module_reference().await?;
let mut exports = BTreeMap::new();
match &self.part {
ModulePart::RenamedExport {
original_export,
export,
} => {
exports.insert(
export.clone(),
EsmExport::ImportedBinding(
ResolvedVc::upcast(reference),
original_export.clone(),
false,
),
);
}
ModulePart::RenamedNamespace { export } => {
exports.insert(
export.clone(),
EsmExport::ImportedNamespace(ResolvedVc::upcast(reference)),
);
}
_ => bail!("Unexpected ModulePart for EcmascriptModuleRenameModule"),
}
let exports = EsmExports {
exports,
star_exports: Vec::new(),
}
.resolved_cell();
Ok(EcmascriptExports::EsmExports(exports).cell())
}
#[turbo_tasks::function]
async fn get_async_module(self: Vc<Self>) -> Result<Vc<OptionAsyncModule>> {
Ok(Vc::cell(Some(self.async_module().to_resolved().await?)))
}
#[turbo_tasks::function]
async fn chunk_item_content(
self: Vc<Self>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
_module_graph: Vc<ModuleGraph>,
async_module_info: Option<Vc<AsyncModuleInfo>>,
_estimated: bool,
) -> Result<Vc<EcmascriptChunkItemContent>> {
let async_module_options = self.get_async_module().module_options(async_module_info);
let content = self.module_content(chunking_context, async_module_info);
Ok(EcmascriptChunkItemContent::new(
content,
chunking_context,
async_module_options,
))
}
}
#[turbo_tasks::value_impl]
impl ChunkableModule for EcmascriptModuleRenameModule {
#[turbo_tasks::function]
fn as_chunk_item(
self: ResolvedVc<Self>,
module_graph: ResolvedVc<ModuleGraph>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
) -> Vc<Box<dyn turbopack_core::chunk::ChunkItem>> {
ecmascript_chunk_item(ResolvedVc::upcast(self), module_graph, chunking_context)
}
}
#[turbo_tasks::value_impl]
impl EvaluatableAsset for EcmascriptModuleRenameModule {}
#[turbo_tasks::value_impl]
impl MergeableModule for EcmascriptModuleRenameModule {
#[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,
entry_points,
EcmascriptOptions::default().resolved_cell(),
)
.await?,
))
}
}
......@@ -31,35 +31,19 @@ use crate::{
side_effect_optimization::reference::EcmascriptModulePartReference,
};
/// A module derived from an original ecmascript module that only contains all
/// A module derived from an original ecmascript module that contains all
/// the reexports from that module and also reexports the locals from
/// [EcmascriptModuleLocalsModule]. It allows to follow
/// [EcmascriptModuleLocalsModule].
#[turbo_tasks::value]
pub struct EcmascriptModuleFacadeModule {
module: ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>,
/// The part of the module that this facade represents.
/// ModulePart::Facade | ModulePart::RenamedExport |
/// ModulePart::RenamedNamespace
part: ModulePart,
}
#[turbo_tasks::value_impl]
impl EcmascriptModuleFacadeModule {
#[turbo_tasks::function]
pub fn new(
module: ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>,
part: ModulePart,
) -> Vc<Self> {
debug_assert!(
matches!(
part,
ModulePart::Facade
| ModulePart::RenamedExport { .. }
| ModulePart::RenamedNamespace { .. }
),
"{part:?} is unexpected for EcmascriptModuleFacadeModule"
);
EcmascriptModuleFacadeModule { module, part }.cell()
pub fn new(module: ResolvedVc<Box<dyn EcmascriptChunkPlaceable>>) -> Vc<Self> {
EcmascriptModuleFacadeModule { module }.cell()
}
#[turbo_tasks::function]
......@@ -88,61 +72,27 @@ impl EcmascriptModuleFacadeModule {
Vec<ResolvedVc<EcmascriptModulePartReference>>,
ResolvedVc<EsmAssetReferences>,
)> {
Ok(match &self.part {
ModulePart::Facade => {
let Some(module) =
ResolvedVc::try_sidecast::<Box<dyn EcmascriptAnalyzable>>(self.module)
else {
bail!(
"Expected EcmascriptModuleAsset for a EcmascriptModuleFacadeModule with \
ModulePart::Facade"
);
};
let result = module.analyze().await?;
(
vec![
// TODO skip if side effect free and no local exports
EcmascriptModulePartReference::new_part(
*self.module,
ModulePart::locals(),
ExportUsage::all(),
)
.to_resolved()
.await?,
],
result.esm_reexport_references,
let Some(module) = ResolvedVc::try_sidecast::<Box<dyn EcmascriptAnalyzable>>(self.module)
else {
bail!(
"Expected EcmascriptModuleAsset for a EcmascriptModuleFacadeModule with \
ModulePart::Facade"
);
};
let result = module.analyze().await?;
Ok((
vec![
// TODO skip if side effect free and no local exports
EcmascriptModulePartReference::new_part(
*self.module,
ModulePart::locals(),
ExportUsage::all(),
)
}
ModulePart::RenamedNamespace { .. } => (
vec![
EcmascriptModulePartReference::new_normal(
*self.module,
self.part.clone(),
ExportUsage::all(),
)
.to_resolved()
.await?,
],
EsmAssetReferences::empty().to_resolved().await?,
),
ModulePart::RenamedExport {
original_export, ..
} => (
vec![
EcmascriptModulePartReference::new_normal(
*self.module,
self.part.clone(),
ExportUsage::named(original_export.clone()),
)
.to_resolved()
.await?,
],
EsmAssetReferences::empty().to_resolved().await?,
),
_ => {
bail!("Unexpected ModulePart for EcmascriptModuleFacadeModule");
}
})
.to_resolved()
.await?,
],
result.esm_reexport_references,
))
}
}
......@@ -150,7 +100,7 @@ impl EcmascriptModuleFacadeModule {
impl Module for EcmascriptModuleFacadeModule {
#[turbo_tasks::function]
fn ident(&self) -> Vc<AssetIdent> {
self.module.ident().with_part(self.part.clone())
self.module.ident().with_part(ModulePart::Facade)
}
#[turbo_tasks::function]
......@@ -183,14 +133,8 @@ impl Module for EcmascriptModuleFacadeModule {
}
#[turbo_tasks::function]
fn side_effects(&self) -> Result<Vc<ModuleSideEffects>> {
Ok(match self.part {
ModulePart::Facade => self.module.side_effects(),
ModulePart::RenamedExport { .. } | ModulePart::RenamedNamespace { .. } => {
ModuleSideEffects::SideEffectFree.cell()
}
_ => bail!("Unexpected ModulePart for EcmascriptModuleFacadeModule"),
})
fn side_effects(&self) -> Vc<ModuleSideEffects> {
ModuleSideEffects::ModuleEvaluationIsSideEffectFree.cell()
}
}
......@@ -246,93 +190,46 @@ impl EcmascriptChunkPlaceable for EcmascriptModuleFacadeModule {
let mut exports = BTreeMap::new();
let mut star_exports = Vec::new();
match &self.part {
ModulePart::Facade => {
let EcmascriptExports::EsmExports(esm_exports) = *self.module.get_exports().await?
else {
bail!(
"EcmascriptModuleFacadeModule must only be used on modules with EsmExports"
let EcmascriptExports::EsmExports(esm_exports) = &*self.module.get_exports().await? else {
bail!("EcmascriptModuleFacadeModule must only be used on modules with EsmExports");
};
let esm_exports = esm_exports.await?;
for (name, export) in &esm_exports.exports {
let name = name.clone();
match export {
EsmExport::LocalBinding(_, liveness) => {
exports.insert(
name.clone(),
EsmExport::ImportedBinding(
ResolvedVc::upcast(
EcmascriptModulePartReference::new_part(
*self.module,
ModulePart::locals(),
ExportUsage::named(name.clone()),
)
.to_resolved()
.await?,
),
name,
*liveness == Liveness::Mutable,
),
);
};
let esm_exports = esm_exports.await?;
for (name, export) in &esm_exports.exports {
let name = name.clone();
match export {
EsmExport::LocalBinding(_, liveness) => {
exports.insert(
name.clone(),
EsmExport::ImportedBinding(
ResolvedVc::upcast(
EcmascriptModulePartReference::new_part(
*self.module,
ModulePart::locals(),
ExportUsage::named(name.clone()),
)
.to_resolved()
.await?,
),
name,
*liveness == Liveness::Mutable,
),
);
}
EsmExport::ImportedNamespace(reference) => {
exports.insert(name, EsmExport::ImportedNamespace(*reference));
}
EsmExport::ImportedBinding(reference, imported_name, mutable) => {
exports.insert(
name,
EsmExport::ImportedBinding(
*reference,
imported_name.clone(),
*mutable,
),
);
}
EsmExport::Error => {
exports.insert(name, EsmExport::Error);
}
}
}
star_exports.extend(esm_exports.star_exports.iter().copied());
}
ModulePart::RenamedExport {
original_export,
export,
} => {
exports.insert(
export.clone(),
EsmExport::ImportedBinding(
ResolvedVc::upcast(
EcmascriptModulePartReference::new_normal(
*self.module,
self.part.clone(),
ExportUsage::named(original_export.clone()),
)
.to_resolved()
.await?,
),
original_export.clone(),
false,
),
);
}
ModulePart::RenamedNamespace { export } => {
exports.insert(
export.clone(),
EsmExport::ImportedNamespace(ResolvedVc::upcast(
EcmascriptModulePartReference::new_normal(
*self.module,
self.part.clone(),
ExportUsage::all(),
)
.to_resolved()
.await?,
)),
);
EsmExport::ImportedNamespace(reference) => {
exports.insert(name, EsmExport::ImportedNamespace(*reference));
}
EsmExport::ImportedBinding(reference, imported_name, mutable) => {
exports.insert(
name,
EsmExport::ImportedBinding(*reference, imported_name.clone(), *mutable),
);
}
EsmExport::Error => {
exports.insert(name, EsmExport::Error);
}
}
_ => bail!("Unexpected ModulePart for EcmascriptModuleFacadeModule"),
}
star_exports.extend(esm_exports.star_exports.iter().copied());
let exports = EsmExports {
exports,
......
......@@ -18,6 +18,7 @@ use crate::{
chunk::EcmascriptChunkPlaceable,
code_gen::{CodeGeneration, CodeGenerationHoistedStmt},
references::esm::base::{ReferencedAsset, ReferencedAssetIdent},
rename::module::EcmascriptModuleRenameModule,
runtime_functions::TURBOPACK_IMPORT,
side_effect_optimization::{
facade::module::EcmascriptModuleFacadeModule, locals::module::EcmascriptModuleLocalsModule,
......@@ -101,11 +102,15 @@ impl ModuleReference for EcmascriptModulePartReference {
};
Vc::upcast::<Box<dyn Module>>(EcmascriptModuleLocalsModule::new(*module))
}
ModulePart::Facade
| ModulePart::RenamedExport { .. }
| ModulePart::RenamedNamespace { .. } => Vc::upcast(
EcmascriptModuleFacadeModule::new(*self.module, self.part.clone()),
),
ModulePart::Facade => {
Vc::upcast(EcmascriptModuleFacadeModule::new(*self.module))
}
ModulePart::RenamedExport { .. } | ModulePart::RenamedNamespace { .. } => {
Vc::upcast(EcmascriptModuleRenameModule::new(
*self.module,
self.part.clone(),
))
}
_ => {
bail!(
"Unexpected ModulePart \"{}\" for EcmascriptModulePartReference",
......
......@@ -24,11 +24,11 @@ use crate::{
EcmascriptModuleAsset, EcmascriptParsable, analyzer::graph::EvalContext, parse::ParseResult,
};
pub mod asset;
mod graph;
pub mod merge;
mod optimizations;
pub mod side_effect_module;
pub mod part;
pub mod side_effects;
#[cfg(test)]
mod tests;
mod util;
......
......@@ -10,7 +10,6 @@ use turbopack_core::{
resolve::{ExportUsage, ModulePart},
};
use super::{SplitResult, get_part_id, part_of_module, split_module};
use crate::{
AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptAnalyzableExt,
EcmascriptModuleAsset, EcmascriptModuleAssetType, EcmascriptModuleContent,
......@@ -23,8 +22,11 @@ use crate::{
references::{
FollowExportsResult, analyze_ecmascript_module, esm::FoundExportType, follow_reexports,
},
side_effect_optimization::facade::module::EcmascriptModuleFacadeModule,
tree_shake::{Key, side_effect_module::SideEffectsModule},
rename::module::EcmascriptModuleRenameModule,
tree_shake::{
Key, SplitResult, get_part_id, part_of_module, side_effects::module::SideEffectsModule,
split_module,
},
};
/// A reference to part of an ES module.
......@@ -41,6 +43,7 @@ impl EcmascriptParsable for EcmascriptModulePartAsset {
#[turbo_tasks::function]
fn failsafe_parse(&self) -> Result<Vc<ParseResult>> {
let split_data = split_module(*self.full_module);
assert_ne!(self.part, ModulePart::Facade);
Ok(part_of_module(split_data, self.part.clone()))
}
#[turbo_tasks::function]
......@@ -187,7 +190,7 @@ impl EcmascriptModulePartAsset {
*final_module
} else {
ResolvedVc::upcast(
EcmascriptModuleFacadeModule::new(
EcmascriptModuleRenameModule::new(
**final_module,
ModulePart::renamed_export(new_export.clone(), export.clone()),
)
......@@ -197,7 +200,7 @@ impl EcmascriptModulePartAsset {
}
} else {
ResolvedVc::upcast(
EcmascriptModuleFacadeModule::new(
EcmascriptModuleRenameModule::new(
**final_module,
ModulePart::renamed_namespace(export.clone()),
)
......
......@@ -25,7 +25,7 @@ use crate::{
};
#[turbo_tasks::value]
pub(super) struct SideEffectsModule {
pub struct SideEffectsModule {
/// Original module
pub module: ResolvedVc<EcmascriptModuleAsset>,
/// The part of the original module that is the binding
......
......@@ -54,8 +54,11 @@ use turbopack_ecmascript::{
external_module::{CachedExternalModule, CachedExternalTracingMode, CachedExternalType},
follow_reexports,
},
side_effect_optimization::facade::module::EcmascriptModuleFacadeModule,
tree_shake::asset::EcmascriptModulePartAsset,
rename::module::EcmascriptModuleRenameModule,
side_effect_optimization::{
facade::module::EcmascriptModuleFacadeModule, locals::module::EcmascriptModuleLocalsModule,
},
tree_shake::part::module::EcmascriptModulePartAsset,
};
use turbopack_node::transforms::webpack::{WebpackLoaderItem, WebpackLoaderItems, WebpackLoaders};
use turbopack_resolve::{
......@@ -196,22 +199,36 @@ async fn apply_module_type(
))
}
Some(TreeShakingMode::ReexportsOnly) => {
// Returns the split module if necessary due to re-exports
if let Some(part) = part {
match part {
ModulePart::Evaluation => Vc::upcast(module.get_locals_if_split()),
ModulePart::Export(_) => {
apply_reexport_tree_shaking(module.get_facade_if_split(), part)
if *module.get_exports().split_locals_and_reexports().await? {
if let Some(part) = part {
match part {
ModulePart::Evaluation => {
Vc::upcast(EcmascriptModuleLocalsModule::new(*module))
}
ModulePart::Export(_) => {
apply_reexport_tree_shaking(
Vc::upcast(
EcmascriptModuleFacadeModule::new(Vc::upcast(
*module,
))
.resolve()
.await?,
),
part,
)
.await?
}
_ => bail!(
"Invalid module part \"{}\" for reexports only tree \
shaking mode",
part
),
}
_ => bail!(
"Invalid module part \"{}\" for reexports only tree shaking \
mode",
part
),
} else {
Vc::upcast(EcmascriptModuleFacadeModule::new(Vc::upcast(*module)))
}
} else {
Vc::upcast(module.get_facade_if_split())
Vc::upcast(*module)
}
}
None => Vc::upcast(*module),
......@@ -292,13 +309,13 @@ async fn apply_reexport_tree_shaking(
if *new_export == *export {
Vc::upcast(**final_module)
} else {
Vc::upcast(EcmascriptModuleFacadeModule::new(
Vc::upcast(EcmascriptModuleRenameModule::new(
**final_module,
ModulePart::renamed_export(new_export.clone(), export.clone()),
))
}
} else {
Vc::upcast(EcmascriptModuleFacadeModule::new(
Vc::upcast(EcmascriptModuleRenameModule::new(
**final_module,
ModulePart::renamed_namespace(export.clone()),
))
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment