Unverified Commit 15b66434 authored by Niklas Mischkulnig's avatar Niklas Mischkulnig Committed by GitHub

Turbopack: codegen EsmAssetReference without turbo tasks (#76024)

Run `EsmAssetReference::code_generation` without cells/turbo tasks.

```
testing against 0293c96cf32


canary 71d8bfcc
14.8gb
529.67s user 81.57s system 883% cpu 1:09.18 total

mischnic/codegen-fewer-tasks 72eba1ead2
14.8gb
533.13s user 82.01s system 874% cpu 1:10.32 total

mischnic/codegen-fewer-tasks don't store twice
14.6gb
529.85s user 82.35s system 875% cpu 1:09.90 total

mischnic/codegen-esm-asset
14.2gb
528.69s user 81.37s system 881% cpu 1:09.17 total
```
parent d69f7965
...@@ -31,19 +31,9 @@ use crate::references::{ ...@@ -31,19 +31,9 @@ use crate::references::{
AstPath, AstPath,
}; };
/// impl of code generation inferred from a ModuleReference.
/// This is rust only and can't be implemented by non-rust plugins.
#[turbo_tasks::value(
shared,
serialization = "none",
eq = "manual",
into = "new",
cell = "new"
)]
#[derive(Default)] #[derive(Default)]
pub struct CodeGeneration { pub struct CodeGeneration {
/// ast nodes matching the span will be visitor by the visitor /// ast nodes matching the span will be visitor by the visitor
#[turbo_tasks(debug_ignore, trace_ignore)]
pub visitors: Vec<(Vec<AstParentKind>, Box<dyn VisitorFactory>)>, pub visitors: Vec<(Vec<AstParentKind>, Box<dyn VisitorFactory>)>,
pub hoisted_stmts: Vec<CodeGenerationHoistedStmt>, pub hoisted_stmts: Vec<CodeGenerationHoistedStmt>,
pub early_hoisted_stmts: Vec<CodeGenerationHoistedStmt>, pub early_hoisted_stmts: Vec<CodeGenerationHoistedStmt>,
...@@ -90,11 +80,9 @@ impl CodeGeneration { ...@@ -90,11 +80,9 @@ impl CodeGeneration {
} }
} }
#[turbo_tasks::value(shared)]
#[derive(Clone)] #[derive(Clone)]
pub struct CodeGenerationHoistedStmt { pub struct CodeGenerationHoistedStmt {
pub key: RcStr, pub key: RcStr,
#[turbo_tasks(trace_ignore)]
pub stmt: Stmt, pub stmt: Stmt,
} }
...@@ -108,15 +96,6 @@ pub trait VisitorFactory: Send + Sync { ...@@ -108,15 +96,6 @@ pub trait VisitorFactory: Send + Sync {
fn create<'a>(&'a self) -> Box<dyn VisitMut + Send + Sync + 'a>; fn create<'a>(&'a self) -> Box<dyn VisitMut + Send + Sync + 'a>;
} }
#[turbo_tasks::value_trait]
pub trait CodeGenerateable {
fn code_generation(
self: Vc<Self>,
module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Vc<CodeGeneration>;
}
#[derive(PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, ValueDebugFormat, NonLocalValue)] #[derive(PartialEq, Eq, Serialize, Deserialize, TraceRawVcs, ValueDebugFormat, NonLocalValue)]
pub enum CodeGen { pub enum CodeGen {
// AMD occurs very rarely and makes the enum much bigger // AMD occurs very rarely and makes the enum much bigger
......
...@@ -42,7 +42,7 @@ use std::{ ...@@ -42,7 +42,7 @@ use std::{
use anyhow::Result; use anyhow::Result;
use chunk::EcmascriptChunkItem; use chunk::EcmascriptChunkItem;
use code_gen::{CodeGenerateable, CodeGeneration, CodeGenerationHoistedStmt}; use code_gen::{CodeGeneration, CodeGenerationHoistedStmt};
use either::Either; use either::Either;
use parse::{parse, ParseResult}; use parse::{parse, ParseResult};
use path_visitor::ApplyVisitors; use path_visitor::ApplyVisitors;
...@@ -95,7 +95,9 @@ use crate::{ ...@@ -95,7 +95,9 @@ use crate::{
chunk::EcmascriptChunkPlaceable, chunk::EcmascriptChunkPlaceable,
code_gen::CodeGens, code_gen::CodeGens,
parse::generate_js_source_map, parse::generate_js_source_map,
references::{analyse_ecmascript_module, async_module::OptionAsyncModule}, references::{
analyse_ecmascript_module, async_module::OptionAsyncModule, esm::base::EsmAssetReferences,
},
transform::remove_shebang, transform::remove_shebang,
}; };
...@@ -417,24 +419,28 @@ impl EcmascriptAnalyzable for EcmascriptModuleAsset { ...@@ -417,24 +419,28 @@ impl EcmascriptAnalyzable for EcmascriptModuleAsset {
) -> Result<Vc<EcmascriptModuleContent>> { ) -> Result<Vc<EcmascriptModuleContent>> {
let parsed = self.parse().to_resolved().await?; let parsed = self.parse().to_resolved().await?;
let analyze = self.analyze().await?; let analyze = self.analyze();
let analyze_ref = analyze.await?;
let module_type_result = *self.determine_module_type().await?; let module_type_result = *self.determine_module_type().await?;
let generate_source_map = chunking_context.reference_module_source_maps(Vc::upcast(self)); let generate_source_map = chunking_context.reference_module_source_maps(Vc::upcast(self));
Ok(EcmascriptModuleContent::new( Ok(EcmascriptModuleContent::new(
*parsed, EcmascriptModuleContentOptions {
self.ident(), parsed,
module_type_result.module_type, ident: self.ident(),
module_graph, specified_module_type: module_type_result.module_type,
chunking_context, module_graph,
*analyze.references, chunking_context,
*analyze.code_generation, references: analyze.references(),
*analyze.async_module, esm_references: *analyze_ref.esm_references,
generate_source_map, code_generation: *analyze_ref.code_generation,
*analyze.source_map, async_module: *analyze_ref.async_module,
*analyze.exports, generate_source_map,
async_module_info, original_source_map: analyze_ref.source_map,
exports: *analyze_ref.exports,
async_module_info,
},
)) ))
} }
} }
...@@ -590,15 +596,13 @@ impl Module for EcmascriptModuleAsset { ...@@ -590,15 +596,13 @@ impl Module for EcmascriptModuleAsset {
#[turbo_tasks::function] #[turbo_tasks::function]
async fn references(self: Vc<Self>) -> Result<Vc<ModuleReferences>> { async fn references(self: Vc<Self>) -> Result<Vc<ModuleReferences>> {
let analyze = self.analyze().await?; Ok(self.analyze().references())
let references = analyze.references.await?.iter().copied().collect();
Ok(Vc::cell(references))
} }
#[turbo_tasks::function] #[turbo_tasks::function]
async fn is_self_async(self: Vc<Self>) -> Result<Vc<bool>> { async fn is_self_async(self: Vc<Self>) -> Result<Vc<bool>> {
if let Some(async_module) = *self.get_async_module().await? { if let Some(async_module) = *self.get_async_module().await? {
Ok(async_module.is_self_async(*self.analyze().await?.references)) Ok(async_module.is_self_async(self.references()))
} else { } else {
Ok(Vc::cell(false)) Ok(Vc::cell(false))
} }
...@@ -756,30 +760,43 @@ pub struct EcmascriptModuleContent { ...@@ -756,30 +760,43 @@ pub struct EcmascriptModuleContent {
// pub refresh: bool, // pub refresh: bool,
} }
#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, TaskInput)]
pub struct EcmascriptModuleContentOptions {
parsed: ResolvedVc<ParseResult>,
ident: Vc<AssetIdent>,
specified_module_type: SpecifiedModuleType,
module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
references: Vc<ModuleReferences>,
esm_references: Vc<EsmAssetReferences>,
code_generation: Vc<CodeGens>,
async_module: Vc<OptionAsyncModule>,
generate_source_map: Vc<bool>,
original_source_map: ResolvedVc<OptionStringifiedSourceMap>,
exports: Vc<EcmascriptExports>,
async_module_info: Option<Vc<AsyncModuleInfo>>,
}
#[turbo_tasks::value_impl] #[turbo_tasks::value_impl]
impl EcmascriptModuleContent { impl EcmascriptModuleContent {
/// Creates a new [`Vc<EcmascriptModuleContent>`]. /// Creates a new [`Vc<EcmascriptModuleContent>`].
#[turbo_tasks::function] #[turbo_tasks::function]
pub async fn new( pub async fn new(input: EcmascriptModuleContentOptions) -> Result<Vc<Self>> {
parsed: ResolvedVc<ParseResult>, let EcmascriptModuleContentOptions {
ident: ResolvedVc<AssetIdent>, parsed,
specified_module_type: SpecifiedModuleType, ident,
module_graph: Vc<ModuleGraph>, specified_module_type,
chunking_context: Vc<Box<dyn ChunkingContext>>, module_graph,
references: Vc<ModuleReferences>, chunking_context,
code_generation: Vc<CodeGens>, references,
async_module: Vc<OptionAsyncModule>, esm_references,
generate_source_map: Vc<bool>, code_generation,
original_source_map: ResolvedVc<OptionStringifiedSourceMap>, async_module,
exports: Vc<EcmascriptExports>, generate_source_map,
async_module_info: Option<Vc<AsyncModuleInfo>>, original_source_map,
) -> Result<Vc<Self>> { exports,
let mut code_gen_cells = Vec::new(); async_module_info,
for r in references.await?.iter() { } = input;
if let Some(code_gen) = ResolvedVc::try_sidecast::<Box<dyn CodeGenerateable>>(*r) {
code_gen_cells.push(code_gen.code_generation(module_graph, chunking_context));
}
}
let additional_code_gens = [ let additional_code_gens = [
if let Some(async_module) = &*async_module.await? { if let Some(async_module) = &*async_module.await? {
...@@ -807,17 +824,21 @@ impl EcmascriptModuleContent { ...@@ -807,17 +824,21 @@ impl EcmascriptModuleContent {
}, },
]; ];
let esm_code_gens = esm_references
.await?
.iter()
.map(|r| r.code_generation(module_graph, chunking_context))
.try_join()
.await?;
let code_gens = code_generation let code_gens = code_generation
.await? .await?
.iter() .iter()
.map(|c| c.code_generation(module_graph, chunking_context)) .map(|c| c.code_generation(module_graph, chunking_context))
.try_join() .try_join()
.await?; .await?;
let code_gen_cells = code_gen_cells.into_iter().try_join().await?;
let code_gens = code_gen_cells let code_gens = esm_code_gens
.iter() .iter()
.map(|c| &**c)
.chain(additional_code_gens.iter().flatten()) .chain(additional_code_gens.iter().flatten())
.chain(code_gens.iter()); .chain(code_gens.iter());
gen_content_with_code_gens( gen_content_with_code_gens(
...@@ -841,7 +862,7 @@ impl EcmascriptModuleContent { ...@@ -841,7 +862,7 @@ impl EcmascriptModuleContent {
) -> Result<Vc<Self>> { ) -> Result<Vc<Self>> {
gen_content_with_code_gens( gen_content_with_code_gens(
parsed.to_resolved().await?, parsed.to_resolved().await?,
ident.to_resolved().await?, ident,
specified_module_type, specified_module_type,
&[], &[],
generate_source_map, generate_source_map,
...@@ -853,7 +874,7 @@ impl EcmascriptModuleContent { ...@@ -853,7 +874,7 @@ impl EcmascriptModuleContent {
async fn gen_content_with_code_gens( async fn gen_content_with_code_gens(
parsed: ResolvedVc<ParseResult>, parsed: ResolvedVc<ParseResult>,
ident: ResolvedVc<AssetIdent>, ident: Vc<AssetIdent>,
specified_module_type: SpecifiedModuleType, specified_module_type: SpecifiedModuleType,
code_gens: impl IntoIterator<Item = &CodeGeneration>, code_gens: impl IntoIterator<Item = &CodeGeneration>,
generate_source_map: Vc<bool>, generate_source_map: Vc<bool>,
......
...@@ -33,7 +33,7 @@ use super::export::{all_known_export_names, is_export_missing}; ...@@ -33,7 +33,7 @@ use super::export::{all_known_export_names, is_export_missing};
use crate::{ use crate::{
analyzer::imports::ImportAnnotations, analyzer::imports::ImportAnnotations,
chunk::EcmascriptChunkPlaceable, chunk::EcmascriptChunkPlaceable,
code_gen::{CodeGenerateable, CodeGeneration}, code_gen::CodeGeneration,
magic_identifier, magic_identifier,
references::util::{request_to_string, throw_module_not_found_expr}, references::util::{request_to_string, throw_module_not_found_expr},
runtime_functions::{TURBOPACK_EXTERNAL_IMPORT, TURBOPACK_EXTERNAL_REQUIRE, TURBOPACK_IMPORT}, runtime_functions::{TURBOPACK_EXTERNAL_IMPORT, TURBOPACK_EXTERNAL_REQUIRE, TURBOPACK_IMPORT},
...@@ -110,6 +110,9 @@ impl ReferencedAsset { ...@@ -110,6 +110,9 @@ impl ReferencedAsset {
} }
} }
#[turbo_tasks::value(transparent)]
pub struct EsmAssetReferences(Vec<ResolvedVc<EsmAssetReference>>);
#[turbo_tasks::value(shared)] #[turbo_tasks::value(shared)]
#[derive(Hash, Debug)] #[derive(Hash, Debug)]
pub struct EsmAssetReference { pub struct EsmAssetReference {
...@@ -252,14 +255,12 @@ impl ChunkableModuleReference for EsmAssetReference { ...@@ -252,14 +255,12 @@ impl ChunkableModuleReference for EsmAssetReference {
} }
} }
#[turbo_tasks::value_impl] impl EsmAssetReference {
impl CodeGenerateable for EsmAssetReference { pub async fn code_generation(
#[turbo_tasks::function]
async fn code_generation(
self: Vc<Self>, self: Vc<Self>,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>, chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Result<Vc<CodeGeneration>> { ) -> Result<CodeGeneration> {
let this = &*self.await?; let this = &*self.await?;
// only chunked references can be imported // only chunked references can be imported
...@@ -392,9 +393,9 @@ impl CodeGenerateable for EsmAssetReference { ...@@ -392,9 +393,9 @@ impl CodeGenerateable for EsmAssetReference {
}; };
if let Some((key, stmt)) = result { if let Some((key, stmt)) = result {
Ok(CodeGeneration::hoisted_stmt(key, stmt).cell()) Ok(CodeGeneration::hoisted_stmt(key, stmt))
} else { } else {
Ok(CodeGeneration::empty().cell()) Ok(CodeGeneration::empty())
} }
} }
} }
......
...@@ -8,7 +8,7 @@ use swc_core::{ ...@@ -8,7 +8,7 @@ use swc_core::{
codegen::{text_writer::JsWriter, Emitter}, codegen::{text_writer::JsWriter, Emitter},
}, },
}; };
use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc}; use turbo_tasks::{ResolvedVc, Vc};
use turbo_tasks_fs::rope::RopeBuilder; use turbo_tasks_fs::rope::RopeBuilder;
use turbopack_core::{ use turbopack_core::{
chunk::{AsyncModuleInfo, ChunkItem, ChunkType, ChunkingContext}, chunk::{AsyncModuleInfo, ChunkItem, ChunkType, ChunkingContext},
...@@ -23,7 +23,6 @@ use crate::{ ...@@ -23,7 +23,6 @@ use crate::{
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkItemOptions, EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkItemOptions,
EcmascriptChunkPlaceable, EcmascriptChunkType, EcmascriptExports, EcmascriptChunkPlaceable, EcmascriptChunkType, EcmascriptExports,
}, },
code_gen::CodeGenerateable,
process_content_with_code_gens, process_content_with_code_gens,
}; };
...@@ -67,21 +66,16 @@ impl EcmascriptChunkItem for EcmascriptModuleFacadeChunkItem { ...@@ -67,21 +66,16 @@ impl EcmascriptChunkItem for EcmascriptModuleFacadeChunkItem {
let mut code = RopeBuilder::default(); let mut code = RopeBuilder::default();
let references = self.module.references(); let esm_code_gens = self
let references_ref = references.await?; .module
let mut code_gens_cells = Vec::with_capacity(references_ref.len() + 2); .code_generation(*self.module_graph, *chunking_context)
for r in &references_ref { .await?;
if let Some(code_gen) = ResolvedVc::try_sidecast::<Box<dyn CodeGenerateable>>(*r) {
code_gens_cells
.push(code_gen.code_generation(*self.module_graph, *chunking_context));
}
}
let additional_code_gens = [ let additional_code_gens = [
self.module self.module
.async_module() .async_module()
.code_generation( .code_generation(
async_module_info, async_module_info,
references, self.module.references(),
*self.module_graph, *self.module_graph,
*chunking_context, *chunking_context,
) )
...@@ -90,11 +84,7 @@ impl EcmascriptChunkItem for EcmascriptModuleFacadeChunkItem { ...@@ -90,11 +84,7 @@ impl EcmascriptChunkItem for EcmascriptModuleFacadeChunkItem {
.code_generation(*self.module_graph, *chunking_context) .code_generation(*self.module_graph, *chunking_context)
.await?, .await?,
]; ];
let code_gen_cells = code_gens_cells.into_iter().try_join().await?; let code_gens = esm_code_gens.iter().chain(additional_code_gens.iter());
let code_gens = code_gen_cells
.iter()
.map(|cg| &**cg)
.chain(additional_code_gens.iter());
let mut program = Program::Module(swc_core::ecma::ast::Module::dummy()); let mut program = Program::Module(swc_core::ecma::ast::Module::dummy());
process_content_with_code_gens(&mut program, &Globals::new(), None, code_gens); process_content_with_code_gens(&mut program, &Globals::new(), None, code_gens);
......
use std::collections::BTreeMap; use std::collections::BTreeMap;
use anyhow::{bail, Result}; use anyhow::{bail, Result};
use turbo_tasks::{ResolvedVc, Vc}; use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};
use turbo_tasks_fs::{glob::Glob, File, FileContent}; use turbo_tasks_fs::{glob::Glob, File, FileContent};
use turbopack_core::{ use turbopack_core::{
asset::{Asset, AssetContent}, asset::{Asset, AssetContent},
...@@ -16,6 +16,7 @@ use turbopack_core::{ ...@@ -16,6 +16,7 @@ use turbopack_core::{
use super::chunk_item::EcmascriptModuleFacadeChunkItem; use super::chunk_item::EcmascriptModuleFacadeChunkItem;
use crate::{ use crate::{
chunk::{EcmascriptChunkPlaceable, EcmascriptExports}, chunk::{EcmascriptChunkPlaceable, EcmascriptExports},
code_gen::CodeGeneration,
references::{ references::{
async_module::{AsyncModule, OptionAsyncModule}, async_module::{AsyncModule, OptionAsyncModule},
esm::{EsmExport, EsmExports}, esm::{EsmExport, EsmExports},
...@@ -59,6 +60,89 @@ impl EcmascriptModuleFacadeModule { ...@@ -59,6 +60,89 @@ impl EcmascriptModuleFacadeModule {
} }
} }
impl EcmascriptModuleFacadeModule {
pub async fn code_generation(
self: Vc<Self>,
module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Result<Vec<CodeGeneration>> {
let this = self.await?;
Ok(match &this.ty {
ModulePart::Evaluation => {
let Some(module) =
ResolvedVc::try_sidecast::<Box<dyn EcmascriptAnalyzable>>(this.module)
else {
bail!(
"Expected EcmascriptModuleAsset for a EcmascriptModuleFacadeModule with \
ModulePart::Evaluation"
);
};
let result = module.analyze().await?;
let mut code_gens = result
.esm_evaluation_references
.await?
.iter()
.map(|r| r.code_generation(module_graph, chunking_context))
.try_join()
.await?;
code_gens.push(
EcmascriptModulePartReference::new_part(*this.module, ModulePart::locals())
.code_generation(module_graph, chunking_context)
.await?,
);
code_gens
}
ModulePart::Exports => {
let Some(module) =
ResolvedVc::try_sidecast::<Box<dyn EcmascriptAnalyzable>>(this.module)
else {
bail!(
"Expected EcmascriptModuleAsset for a EcmascriptModuleFacadeModule with \
ModulePart::Exports"
);
};
let result = module.analyze().await?;
let mut code_gens = result
.esm_reexport_references
.await?
.iter()
.map(|r| r.code_generation(module_graph, chunking_context))
.try_join()
.await?;
code_gens.push(
EcmascriptModulePartReference::new_part(*this.module, ModulePart::locals())
.code_generation(module_graph, chunking_context)
.await?,
);
code_gens
}
ModulePart::Facade => {
vec![
EcmascriptModulePartReference::new_part(*this.module, ModulePart::evaluation())
.code_generation(module_graph, chunking_context)
.await?,
EcmascriptModulePartReference::new_part(*this.module, ModulePart::exports())
.code_generation(module_graph, chunking_context)
.await?,
]
}
ModulePart::RenamedNamespace { .. } => vec![
EcmascriptModulePartReference::new(*this.module)
.code_generation(module_graph, chunking_context)
.await?,
],
ModulePart::RenamedExport { .. } => vec![
EcmascriptModulePartReference::new(*this.module)
.code_generation(module_graph, chunking_context)
.await?,
],
_ => {
bail!("Unexpected ModulePart for EcmascriptModuleFacadeModule");
}
})
}
}
#[turbo_tasks::value_impl] #[turbo_tasks::value_impl]
impl Module for EcmascriptModuleFacadeModule { impl Module for EcmascriptModuleFacadeModule {
#[turbo_tasks::function] #[turbo_tasks::function]
...@@ -81,14 +165,17 @@ impl Module for EcmascriptModuleFacadeModule { ...@@ -81,14 +165,17 @@ impl Module for EcmascriptModuleFacadeModule {
); );
}; };
let result = module.analyze().await?; let result = module.analyze().await?;
let references = result.evaluation_references; result
let mut references = references.owned().await?; .esm_evaluation_references
references.push(ResolvedVc::upcast( .await?
EcmascriptModulePartReference::new_part(*self.module, ModulePart::locals()) .iter()
.to_resolved() .map(|r| ResolvedVc::upcast(*r))
.await?, .chain(std::iter::once(ResolvedVc::upcast(
)); EcmascriptModulePartReference::new_part(*self.module, ModulePart::locals())
references .to_resolved()
.await?,
)))
.collect()
} }
ModulePart::Exports => { ModulePart::Exports => {
let Some(module) = let Some(module) =
...@@ -96,18 +183,21 @@ impl Module for EcmascriptModuleFacadeModule { ...@@ -96,18 +183,21 @@ impl Module for EcmascriptModuleFacadeModule {
else { else {
bail!( bail!(
"Expected EcmascriptModuleAsset for a EcmascriptModuleFacadeModule with \ "Expected EcmascriptModuleAsset for a EcmascriptModuleFacadeModule with \
ModulePart::Evaluation" ModulePart::Exports"
); );
}; };
let result = module.analyze().await?; let result = module.analyze().await?;
let references = result.reexport_references; result
let mut references = references.owned().await?; .esm_reexport_references
references.push(ResolvedVc::upcast( .await?
EcmascriptModulePartReference::new_part(*self.module, ModulePart::locals()) .iter()
.to_resolved() .map(|r| ResolvedVc::upcast(*r))
.await?, .chain(std::iter::once(ResolvedVc::upcast(
)); EcmascriptModulePartReference::new_part(*self.module, ModulePart::locals())
references .to_resolved()
.await?,
)))
.collect()
} }
ModulePart::Facade => { ModulePart::Facade => {
vec![ vec![
......
...@@ -13,7 +13,7 @@ use crate::{ ...@@ -13,7 +13,7 @@ use crate::{
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable, EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
EcmascriptChunkType, EcmascriptChunkType,
}, },
EcmascriptModuleContent, EcmascriptModuleContent, EcmascriptModuleContentOptions,
}; };
/// The chunk item for [EcmascriptModuleLocalsModule]. /// The chunk item for [EcmascriptModuleLocalsModule].
...@@ -41,9 +41,10 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem { ...@@ -41,9 +41,10 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem {
let module_graph = self.module_graph; let module_graph = self.module_graph;
let exports = self.module.get_exports(); let exports = self.module.get_exports();
let original_module = module.module; let original_module = module.module;
let parsed = original_module.parse().resolve().await?; let parsed = original_module.parse().to_resolved().await?;
let analyze_result = original_module.analyze().await?; let analyze = original_module.analyze();
let analyze_result = analyze.await?;
let async_module_options = analyze_result let async_module_options = analyze_result
.async_module .async_module
.module_options(async_module_info); .module_options(async_module_info);
...@@ -52,20 +53,21 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem { ...@@ -52,20 +53,21 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem {
let generate_source_map = let generate_source_map =
chunking_context.reference_module_source_maps(*ResolvedVc::upcast(self.module)); chunking_context.reference_module_source_maps(*ResolvedVc::upcast(self.module));
let content = EcmascriptModuleContent::new( let content = EcmascriptModuleContent::new(EcmascriptModuleContentOptions {
parsed, parsed,
self.module.ident(), ident: self.module.ident(),
module_type_result.module_type, specified_module_type: module_type_result.module_type,
*module_graph, module_graph: *module_graph,
*chunking_context, chunking_context: *chunking_context,
*analyze_result.local_references, references: analyze.local_references(),
*analyze_result.code_generation, esm_references: *analyze_result.esm_local_references,
*analyze_result.async_module, code_generation: *analyze_result.code_generation,
async_module: *analyze_result.async_module,
generate_source_map, generate_source_map,
*analyze_result.source_map, original_source_map: analyze_result.source_map,
exports, exports,
async_module_info, async_module_info,
); });
Ok(EcmascriptChunkItemContent::new( Ok(EcmascriptChunkItemContent::new(
content, content,
......
...@@ -50,15 +50,15 @@ impl Module for EcmascriptModuleLocalsModule { ...@@ -50,15 +50,15 @@ impl Module for EcmascriptModuleLocalsModule {
#[turbo_tasks::function] #[turbo_tasks::function]
async fn references(&self) -> Result<Vc<ModuleReferences>> { async fn references(&self) -> Result<Vc<ModuleReferences>> {
let result = self.module.analyze().await?; let result = self.module.analyze();
Ok(*result.local_references) Ok(result.local_references())
} }
#[turbo_tasks::function] #[turbo_tasks::function]
async fn is_self_async(&self) -> Result<Vc<bool>> { async fn is_self_async(self: Vc<Self>) -> Result<Vc<bool>> {
let analyze = self.module.analyze().await?; let analyze = self.await?.module.analyze().await?;
if let Some(async_module) = *analyze.async_module.await? { if let Some(async_module) = *analyze.async_module.await? {
let is_self_async = async_module.is_self_async(*analyze.local_references); let is_self_async = async_module.is_self_async(self.references());
Ok(is_self_async) Ok(is_self_async)
} else { } else {
Ok(Vc::cell(false)) Ok(Vc::cell(false))
......
...@@ -17,10 +17,8 @@ use super::{ ...@@ -17,10 +17,8 @@ use super::{
facade::module::EcmascriptModuleFacadeModule, locals::module::EcmascriptModuleLocalsModule, facade::module::EcmascriptModuleFacadeModule, locals::module::EcmascriptModuleLocalsModule,
}; };
use crate::{ use crate::{
chunk::EcmascriptChunkPlaceable, chunk::EcmascriptChunkPlaceable, code_gen::CodeGeneration,
code_gen::{CodeGenerateable, CodeGeneration}, references::esm::base::ReferencedAsset, runtime_functions::TURBOPACK_IMPORT,
references::esm::base::ReferencedAsset,
runtime_functions::TURBOPACK_IMPORT,
utils::module_id_to_lit, utils::module_id_to_lit,
}; };
...@@ -111,14 +109,12 @@ impl ChunkableModuleReference for EcmascriptModulePartReference { ...@@ -111,14 +109,12 @@ impl ChunkableModuleReference for EcmascriptModulePartReference {
} }
} }
#[turbo_tasks::value_impl] impl EcmascriptModulePartReference {
impl CodeGenerateable for EcmascriptModulePartReference { pub async fn code_generation(
#[turbo_tasks::function]
async fn code_generation(
self: Vc<Self>, self: Vc<Self>,
module_graph: Vc<ModuleGraph>, module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>, chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Result<Vc<CodeGeneration>> { ) -> Result<CodeGeneration> {
let referenced_asset = ReferencedAsset::from_resolve_result(self.resolve_reference()); let referenced_asset = ReferencedAsset::from_resolve_result(self.resolve_reference());
let referenced_asset = referenced_asset.await?; let referenced_asset = referenced_asset.await?;
let ident = referenced_asset let ident = referenced_asset
...@@ -142,7 +138,6 @@ impl CodeGenerateable for EcmascriptModulePartReference { ...@@ -142,7 +138,6 @@ impl CodeGenerateable for EcmascriptModulePartReference {
turbopack_import: Expr = TURBOPACK_IMPORT.into(), turbopack_import: Expr = TURBOPACK_IMPORT.into(),
id: Expr = module_id_to_lit(&id), id: Expr = module_id_to_lit(&id),
), ),
) ))
.cell())
} }
} }
...@@ -292,11 +292,11 @@ impl Module for EcmascriptModulePartAsset { ...@@ -292,11 +292,11 @@ impl Module for EcmascriptModulePartAsset {
async fn references(&self) -> Result<Vc<ModuleReferences>> { async fn references(&self) -> Result<Vc<ModuleReferences>> {
let split_data = split_module(*self.full_module).await?; let split_data = split_module(*self.full_module).await?;
let analyze = analyze(*self.full_module, self.part.clone()).await?; let analyze = analyze(*self.full_module, self.part.clone());
let deps = match &*split_data { let deps = match &*split_data {
SplitResult::Ok { deps, .. } => deps, SplitResult::Ok { deps, .. } => deps,
SplitResult::Failed { .. } => return Ok(*analyze.references), SplitResult::Failed { .. } => return Ok(analyze.references()),
}; };
let part_dep = |part: ModulePart| -> Vc<Box<dyn ModuleReference>> { let part_dep = |part: ModulePart| -> Vc<Box<dyn ModuleReference>> {
...@@ -306,7 +306,7 @@ impl Module for EcmascriptModulePartAsset { ...@@ -306,7 +306,7 @@ impl Module for EcmascriptModulePartAsset {
)) ))
}; };
let mut references = analyze.references.await?.to_vec(); let mut references = analyze.references().owned().await?;
// Facade depends on evaluation and re-exports // Facade depends on evaluation and re-exports
if self.part == ModulePart::Facade { if self.part == ModulePart::Facade {
......
...@@ -20,7 +20,7 @@ use crate::{ ...@@ -20,7 +20,7 @@ use crate::{
runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT}, runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
tree_shake::side_effect_module::SideEffectsModule, tree_shake::side_effect_module::SideEffectsModule,
utils::StringifyModuleId, utils::StringifyModuleId,
EcmascriptModuleContent, EcmascriptModuleContent, EcmascriptModuleContentOptions,
}; };
/// This is an implementation of [ChunkItem] for /// This is an implementation of [ChunkItem] for
...@@ -49,30 +49,34 @@ impl EcmascriptChunkItem for EcmascriptModulePartChunkItem { ...@@ -49,30 +49,34 @@ impl EcmascriptChunkItem for EcmascriptModulePartChunkItem {
let module = self.module.await?; let module = self.module.await?;
let split_data = split_module(*module.full_module); let split_data = split_module(*module.full_module);
let parsed = part_of_module(split_data, module.part.clone()); let parsed = part_of_module(split_data, module.part.clone())
.to_resolved()
.await?;
let analyze = self.module.analyze().await?; let analyze = self.module.analyze();
let async_module_options = analyze.async_module.module_options(async_module_info); let analyze_ref = analyze.await?;
let async_module_options = analyze_ref.async_module.module_options(async_module_info);
let module_type_result = *module.full_module.determine_module_type().await?; let module_type_result = *module.full_module.determine_module_type().await?;
let generate_source_map = self let generate_source_map = self
.chunking_context .chunking_context
.reference_module_source_maps(*ResolvedVc::upcast(self.module)); .reference_module_source_maps(*ResolvedVc::upcast(self.module));
let content = EcmascriptModuleContent::new( let content = EcmascriptModuleContent::new(EcmascriptModuleContentOptions {
parsed, parsed,
self.module.ident(), ident: self.module.ident(),
module_type_result.module_type, specified_module_type: module_type_result.module_type,
*self.module_graph, module_graph: *self.module_graph,
*self.chunking_context, chunking_context: *self.chunking_context,
*analyze.references, references: analyze.references(),
*analyze.code_generation, esm_references: *analyze_ref.esm_references,
*analyze.async_module, code_generation: *analyze_ref.code_generation,
async_module: *analyze_ref.async_module,
generate_source_map, generate_source_map,
*analyze.source_map, original_source_map: analyze_ref.source_map,
*analyze.exports, exports: *analyze_ref.exports,
async_module_info, async_module_info,
); });
Ok(EcmascriptChunkItemContent::new( Ok(EcmascriptChunkItemContent::new(
content, content,
......
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