Unverified Commit 43a4c628 authored by Niklas Mischkulnig's avatar Niklas Mischkulnig Committed by GitHub

Turbopack: refactor codegen of module fragments (#78642)

So that every type of ecmascript chunk item uses `EcmascriptModuleContent::new`
parent 6c09eab8
......@@ -153,6 +153,14 @@ impl CodeGen {
#[turbo_tasks::value(transparent)]
pub struct CodeGens(Vec<CodeGen>);
#[turbo_tasks::value_impl]
impl CodeGens {
#[turbo_tasks::function]
pub fn empty() -> Vc<Self> {
Vc::cell(Vec::new())
}
}
pub trait IntoCodeGenReference {
fn into_code_gen_reference(
self,
......
......@@ -98,6 +98,7 @@ use crate::{
references::{
analyse_ecmascript_module, async_module::OptionAsyncModule, esm::base::EsmAssetReferences,
},
side_effect_optimization::reference::EcmascriptModulePartReference,
transform::remove_shebang,
};
......@@ -124,6 +125,7 @@ pub enum SpecifiedModuleType {
Deserialize,
TraceRawVcs,
NonLocalValue,
TaskInput,
)]
#[serde(rename_all = "kebab-case")]
pub enum TreeShakingMode {
......@@ -436,6 +438,7 @@ impl EcmascriptAnalyzable for EcmascriptModuleAsset {
chunking_context,
references: analyze.references().to_resolved().await?,
esm_references: analyze_ref.esm_references,
part_references: vec![],
code_generation: analyze_ref.code_generation,
async_module: analyze_ref.async_module,
generate_source_map,
......@@ -747,30 +750,35 @@ impl EcmascriptChunkItem for ModuleChunkItem {
self: Vc<Self>,
async_module_info: Option<Vc<AsyncModuleInfo>>,
) -> Result<Vc<EcmascriptChunkItemContent>> {
let this = self.await?;
let _span = tracing::info_span!(
let span = tracing::info_span!(
"code generation",
module = self.asset_ident().to_string().await?.to_string()
)
.entered();
let async_module_options = this
.module
.get_async_module()
.module_options(async_module_info);
// TODO check if we need to pass async_module_info at all
let content = this.module.module_content(
*this.module_graph,
*this.chunking_context,
async_module_info,
);
async {
let this = self.await?;
let async_module_options = this
.module
.get_async_module()
.module_options(async_module_info);
// TODO check if we need to pass async_module_info at all
let content = this.module.module_content(
*this.module_graph,
*this.chunking_context,
async_module_info,
);
Ok(EcmascriptChunkItemContent::new(
content,
*this.chunking_context,
this.module.options(),
async_module_options,
))
EcmascriptChunkItemContent::new(
content,
*this.chunking_context,
this.module.options(),
async_module_options,
)
.resolve()
.await
}
.instrument(span)
.await
}
}
......@@ -792,6 +800,7 @@ pub struct EcmascriptModuleContentOptions {
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
references: ResolvedVc<ModuleReferences>,
esm_references: ResolvedVc<EsmAssetReferences>,
part_references: Vec<ResolvedVc<EcmascriptModulePartReference>>,
code_generation: ResolvedVc<CodeGens>,
async_module: ResolvedVc<OptionAsyncModule>,
generate_source_map: bool,
......@@ -813,6 +822,7 @@ impl EcmascriptModuleContent {
chunking_context,
references,
esm_references,
part_references,
code_generation,
async_module,
generate_source_map,
......@@ -821,7 +831,7 @@ impl EcmascriptModuleContent {
async_module_info,
} = input;
let (esm_code_gens, additional_code_gens, code_gens) = async {
let (esm_code_gens, part_code_gens, additional_code_gens, code_gens) = async {
let additional_code_gens = [
if let Some(async_module) = &*async_module.await? {
Some(
......@@ -853,6 +863,13 @@ impl EcmascriptModuleContent {
.map(|r| r.code_generation(*chunking_context))
.try_join()
.await?;
let part_code_gens = part_references
.iter()
.map(|r| r.code_generation(*chunking_context))
.try_join()
.await?;
let code_gens = code_generation
.await?
.iter()
......@@ -860,13 +877,19 @@ impl EcmascriptModuleContent {
.try_join()
.await?;
anyhow::Ok((esm_code_gens, additional_code_gens, code_gens))
anyhow::Ok((
esm_code_gens,
part_code_gens,
additional_code_gens,
code_gens,
))
}
.instrument(tracing::info_span!("precompute code generation"))
.await?;
let code_gens = esm_code_gens
.iter()
.chain(part_code_gens.iter())
.chain(additional_code_gens.iter().flatten())
.chain(code_gens.iter());
......
......@@ -8,6 +8,7 @@ use swc_core::{
errors::{Handler, HANDLER},
input::StringInput,
source_map::SourceMapGenConfig,
util::take::Take,
BytePos, FileName, Globals, LineCol, Mark, SyntaxContext, GLOBALS,
},
ecma::{
......@@ -38,7 +39,7 @@ use turbopack_swc_utils::emitter::IssueEmitter;
use super::EcmascriptModuleAssetType;
use crate::{
analyzer::graph::EvalContext,
analyzer::{graph::EvalContext, ImportMap},
swc_comments::ImmutableComments,
transform::{EcmascriptInputTransforms, TransformContext},
EcmascriptInputTransform,
......@@ -75,6 +76,28 @@ impl PartialEq for ParseResult {
}
}
#[turbo_tasks::value_impl]
impl ParseResult {
#[turbo_tasks::function]
pub fn empty() -> Vc<ParseResult> {
let globals = Globals::new();
let eval_context = GLOBALS.set(&globals, || EvalContext {
unresolved_mark: Mark::new(),
top_level_mark: Mark::new(),
imports: ImportMap::default(),
force_free_values: Default::default(),
});
ParseResult::Ok {
program: Program::Module(swc_core::ecma::ast::Module::dummy()),
comments: Default::default(),
eval_context,
globals: Arc::new(globals),
source_map: Default::default(),
}
.cell()
}
}
pub fn generate_js_source_map(
files_map: Arc<swc_core::common::SourceMap>,
mappings: Vec<(BytePos, LineCol)>,
......
......@@ -109,6 +109,14 @@ impl ReferencedAsset {
#[turbo_tasks::value(transparent)]
pub struct EsmAssetReferences(Vec<ResolvedVc<EsmAssetReference>>);
#[turbo_tasks::value_impl]
impl EsmAssetReferences {
#[turbo_tasks::function]
pub fn empty() -> Vc<Self> {
Vc::cell(Vec::new())
}
}
#[turbo_tasks::value(shared)]
#[derive(Hash, Debug)]
pub struct EsmAssetReference {
......
use std::sync::Arc;
use anyhow::{bail, Result};
use swc_core::{
common::{util::take::Take, Globals},
ecma::{
ast::Program,
codegen::{text_writer::JsWriter, Emitter},
},
};
use anyhow::Result;
use turbo_tasks::{ResolvedVc, Vc};
use turbo_tasks_fs::rope::RopeBuilder;
use turbopack_core::{
chunk::{AsyncModuleInfo, ChunkItem, ChunkType, ChunkingContext},
ident::AssetIdent,
......@@ -20,10 +10,10 @@ use turbopack_core::{
use super::module::EcmascriptModuleFacadeModule;
use crate::{
chunk::{
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkItemOptions,
EcmascriptChunkPlaceable, EcmascriptChunkType, EcmascriptExports,
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
EcmascriptChunkType,
},
process_content_with_code_gens,
EcmascriptAnalyzable, EcmascriptOptions,
};
/// The chunk item for [EcmascriptModuleFacadeModule].
......@@ -47,74 +37,23 @@ impl EcmascriptChunkItem for EcmascriptModuleFacadeChunkItem {
async_module_info: Option<Vc<AsyncModuleInfo>>,
) -> Result<Vc<EcmascriptChunkItemContent>> {
let chunking_context = self.chunking_context;
let exports = self.module.get_exports();
let EcmascriptExports::EsmExports(exports) = *exports.await? else {
bail!("Expected EsmExports");
};
let module_graph = self.module_graph;
let externals = *chunking_context
.environment()
.supports_commonjs_externals()
.await?;
let content =
self.module
.module_content(*module_graph, *chunking_context, async_module_info);
let async_module_options = self
.module
.get_async_module()
.module_options(async_module_info);
let async_module = async_module_options.owned().await?;
let mut code = RopeBuilder::default();
let esm_code_gens = self
.module
.code_generation(*self.module_graph, *chunking_context)
.await?;
let additional_code_gens = [
self.module
.async_module()
.code_generation(
async_module_info,
self.module.references(),
*chunking_context,
)
.await?,
exports
.code_generation(*self.module_graph, *chunking_context, None)
.await?,
];
let code_gens = esm_code_gens.iter().chain(additional_code_gens.iter());
let mut program = Program::Module(swc_core::ecma::ast::Module::dummy());
process_content_with_code_gens(&mut program, &Globals::new(), None, code_gens);
let mut bytes: Vec<u8> = vec![];
let source_map: Arc<swc_core::common::SourceMap> = Default::default();
let mut emitter = Emitter {
cfg: swc_core::ecma::codegen::Config::default(),
cm: source_map.clone(),
comments: None,
wr: JsWriter::new(source_map.clone(), "\n", &mut bytes, None),
};
emitter.emit_program(&program)?;
code.push_bytes(&bytes);
Ok(EcmascriptChunkItemContent {
inner_code: code.build(),
source_map: None,
options: EcmascriptChunkItemOptions {
strict: true,
externals,
async_module,
..Default::default()
},
..Default::default()
}
.cell())
Ok(EcmascriptChunkItemContent::new(
content,
*chunking_context,
EcmascriptOptions::default().cell(),
async_module_options,
))
}
}
......
......@@ -9,11 +9,8 @@ use turbopack_core::{
use super::module::EcmascriptModuleLocalsModule;
use crate::{
chunk::{
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
EcmascriptChunkType,
},
EcmascriptModuleContent, EcmascriptModuleContentOptions,
chunk::{EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkType},
EcmascriptAnalyzable,
};
/// The chunk item for [EcmascriptModuleLocalsModule].
......@@ -34,41 +31,22 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem {
#[turbo_tasks::function]
async fn content_with_async_module_info(
&self,
async_module_info: Option<ResolvedVc<AsyncModuleInfo>>,
async_module_info: Option<Vc<AsyncModuleInfo>>,
) -> Result<Vc<EcmascriptChunkItemContent>> {
let module = self.module.await?;
let chunking_context = self.chunking_context;
let module_graph = self.module_graph;
let exports = self.module.get_exports().to_resolved().await?;
let original_module = module.module;
let parsed = original_module.parse().to_resolved().await?;
let analyze = original_module.analyze();
let analyze_result = analyze.await?;
let async_module_options = analyze_result
.async_module
.module_options(async_module_info.map(|info| *info));
.module_options(async_module_info);
let module_type_result = *original_module.determine_module_type().await?;
let generate_source_map = *chunking_context
.reference_module_source_maps(*ResolvedVc::upcast(self.module))
.await?;
let content = EcmascriptModuleContent::new(EcmascriptModuleContentOptions {
parsed,
ident: self.module.ident().to_resolved().await?,
specified_module_type: module_type_result.module_type,
module_graph,
chunking_context,
references: analyze.local_references().to_resolved().await?,
esm_references: analyze_result.esm_local_references,
code_generation: analyze_result.code_generation,
async_module: analyze_result.async_module,
generate_source_map,
original_source_map: analyze_result.source_map,
exports,
async_module_info,
});
let content =
self.module
.module_content(*module_graph, *chunking_context, async_module_info);
Ok(EcmascriptChunkItemContent::new(
content,
......
......@@ -5,7 +5,7 @@ use turbo_tasks::{ResolvedVc, Vc};
use turbo_tasks_fs::glob::Glob;
use turbopack_core::{
asset::{Asset, AssetContent},
chunk::{ChunkableModule, ChunkingContext},
chunk::{AsyncModuleInfo, ChunkableModule, ChunkingContext},
ident::AssetIdent,
module::Module,
module_graph::ModuleGraph,
......@@ -20,7 +20,8 @@ use crate::{
async_module::OptionAsyncModule,
esm::{EsmExport, EsmExports},
},
EcmascriptModuleAsset,
AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptModuleAsset,
EcmascriptModuleContent, EcmascriptModuleContentOptions,
};
/// A module derived from an original ecmascript module that only contains the
......@@ -74,6 +75,62 @@ impl Asset for EcmascriptModuleLocalsModule {
}
}
#[turbo_tasks::value_impl]
impl EcmascriptAnalyzable for EcmascriptModuleLocalsModule {
#[turbo_tasks::function]
fn analyze(&self) -> Vc<AnalyzeEcmascriptModuleResult> {
self.module.analyze()
}
#[turbo_tasks::function]
fn module_content_without_analysis(
&self,
generate_source_map: bool,
) -> Vc<EcmascriptModuleContent> {
self.module
.module_content_without_analysis(generate_source_map)
}
#[turbo_tasks::function]
async fn module_content(
self: Vc<Self>,
module_graph: ResolvedVc<ModuleGraph>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
async_module_info: Option<ResolvedVc<AsyncModuleInfo>>,
) -> Result<Vc<EcmascriptModuleContent>> {
let exports = self.get_exports().to_resolved().await?;
let original_module = self.await?.module;
let parsed = original_module.parse().to_resolved().await?;
let analyze = original_module.analyze();
let analyze_result = analyze.await?;
let module_type_result = *original_module.determine_module_type().await?;
let generate_source_map = *chunking_context
.reference_module_source_maps(Vc::upcast(self))
.await?;
Ok(EcmascriptModuleContent::new(
EcmascriptModuleContentOptions {
parsed,
ident: self.ident().to_resolved().await?,
specified_module_type: module_type_result.module_type,
module_graph,
chunking_context,
references: analyze.local_references().to_resolved().await?,
esm_references: analyze_result.esm_local_references,
part_references: vec![],
code_generation: analyze_result.code_generation,
async_module: analyze_result.async_module,
generate_source_map,
original_source_map: analyze_result.source_map,
exports,
async_module_info,
},
))
}
}
#[turbo_tasks::value_impl]
impl EcmascriptChunkPlaceable for EcmascriptModuleLocalsModule {
#[turbo_tasks::function]
......
......@@ -8,7 +8,6 @@ use turbopack_core::{
ModuleChunkItemIdExt,
},
module::Module,
module_graph::ModuleGraph,
reference::ModuleReference,
resolve::{ModulePart, ModuleResolveResult},
};
......@@ -110,7 +109,6 @@ impl ChunkableModuleReference for EcmascriptModulePartReference {
impl EcmascriptModulePartReference {
pub async fn code_generation(
self: Vc<Self>,
_module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Result<CodeGeneration> {
let referenced_asset = ReferencedAsset::from_resolve_result(self.resolve_reference());
......
......@@ -26,7 +26,8 @@ use crate::{
side_effect_optimization::facade::module::EcmascriptModuleFacadeModule,
tree_shake::{side_effect_module::SideEffectsModule, Key},
AnalyzeEcmascriptModuleResult, EcmascriptAnalyzable, EcmascriptModuleAsset,
EcmascriptModuleAssetType, EcmascriptModuleContent, EcmascriptParsable,
EcmascriptModuleAssetType, EcmascriptModuleContent, EcmascriptModuleContentOptions,
EcmascriptParsable,
};
/// A reference to part of an ES module.
......@@ -74,14 +75,45 @@ impl EcmascriptAnalyzable for EcmascriptModulePartAsset {
}
#[turbo_tasks::function]
fn module_content(
&self,
module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
async_module_info: Option<Vc<AsyncModuleInfo>>,
) -> Vc<EcmascriptModuleContent> {
self.full_module
.module_content(module_graph, chunking_context, async_module_info)
async fn module_content(
self: Vc<Self>,
module_graph: ResolvedVc<ModuleGraph>,
chunking_context: ResolvedVc<Box<dyn ChunkingContext>>,
async_module_info: Option<ResolvedVc<AsyncModuleInfo>>,
) -> Result<Vc<EcmascriptModuleContent>> {
let module = self.await?;
let split_data = split_module(*module.full_module);
let parsed = part_of_module(split_data, module.part.clone())
.to_resolved()
.await?;
let analyze = self.analyze();
let analyze_ref = analyze.await?;
let module_type_result = *module.full_module.determine_module_type().await?;
let generate_source_map = *chunking_context
.reference_module_source_maps(Vc::upcast(self))
.await?;
Ok(EcmascriptModuleContent::new(
EcmascriptModuleContentOptions {
parsed,
ident: self.ident().to_resolved().await?,
specified_module_type: module_type_result.module_type,
module_graph,
chunking_context,
references: analyze.references().to_resolved().await?,
esm_references: analyze_ref.esm_references,
part_references: vec![],
code_generation: analyze_ref.code_generation,
async_module: analyze_ref.async_module,
generate_source_map,
original_source_map: analyze_ref.source_map,
exports: analyze_ref.exports,
async_module_info,
},
))
}
}
......
......@@ -8,7 +8,7 @@ use turbopack_core::{
module_graph::ModuleGraph,
};
use super::{asset::EcmascriptModulePartAsset, part_of_module, split_module};
use super::asset::EcmascriptModulePartAsset;
use crate::{
chunk::{
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkItemOptions,
......@@ -18,7 +18,7 @@ use crate::{
runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
tree_shake::side_effect_module::SideEffectsModule,
utils::StringifyModuleId,
EcmascriptModuleContent, EcmascriptModuleContentOptions,
EcmascriptAnalyzable,
};
/// This is an implementation of [ChunkItem] for
......@@ -42,47 +42,22 @@ impl EcmascriptChunkItem for EcmascriptModulePartChunkItem {
#[turbo_tasks::function]
async fn content_with_async_module_info(
&self,
async_module_info: Option<ResolvedVc<AsyncModuleInfo>>,
async_module_info: Option<Vc<AsyncModuleInfo>>,
) -> Result<Vc<EcmascriptChunkItemContent>> {
let module = self.module.await?;
let split_data = split_module(*module.full_module);
let parsed = part_of_module(split_data, module.part.clone())
.to_resolved()
.await?;
let analyze = self.module.analyze();
let analyze_ref = analyze.await?;
let async_module_options = analyze_ref
.async_module
.module_options(async_module_info.map(|info| *info));
let module_type_result = *module.full_module.determine_module_type().await?;
let generate_source_map = *self
.chunking_context
.reference_module_source_maps(*ResolvedVc::upcast(self.module))
.await?;
let content = EcmascriptModuleContent::new(EcmascriptModuleContentOptions {
parsed,
ident: self.module.ident().to_resolved().await?,
specified_module_type: module_type_result.module_type,
module_graph: self.module_graph,
chunking_context: self.chunking_context,
references: analyze.references().to_resolved().await?,
esm_references: analyze_ref.esm_references,
code_generation: analyze_ref.code_generation,
async_module: analyze_ref.async_module,
generate_source_map,
original_source_map: analyze_ref.source_map,
exports: analyze_ref.exports,
let async_module_options = analyze_ref.async_module.module_options(async_module_info);
let content = self.module.module_content(
*self.module_graph,
*self.chunking_context,
async_module_info,
});
);
Ok(EcmascriptChunkItemContent::new(
content,
*self.chunking_context,
*module.full_module.await?.options,
*self.module.await?.full_module.await?.options,
async_module_options,
))
}
......
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