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::{
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)]
pub struct CodeGeneration {
/// 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 hoisted_stmts: Vec<CodeGenerationHoistedStmt>,
pub early_hoisted_stmts: Vec<CodeGenerationHoistedStmt>,
......@@ -90,11 +80,9 @@ impl CodeGeneration {
}
}
#[turbo_tasks::value(shared)]
#[derive(Clone)]
pub struct CodeGenerationHoistedStmt {
pub key: RcStr,
#[turbo_tasks(trace_ignore)]
pub stmt: Stmt,
}
......@@ -108,15 +96,6 @@ pub trait VisitorFactory: Send + Sync {
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)]
pub enum CodeGen {
// AMD occurs very rarely and makes the enum much bigger
......
......@@ -42,7 +42,7 @@ use std::{
use anyhow::Result;
use chunk::EcmascriptChunkItem;
use code_gen::{CodeGenerateable, CodeGeneration, CodeGenerationHoistedStmt};
use code_gen::{CodeGeneration, CodeGenerationHoistedStmt};
use either::Either;
use parse::{parse, ParseResult};
use path_visitor::ApplyVisitors;
......@@ -95,7 +95,9 @@ use crate::{
chunk::EcmascriptChunkPlaceable,
code_gen::CodeGens,
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,
};
......@@ -417,24 +419,28 @@ impl EcmascriptAnalyzable for EcmascriptModuleAsset {
) -> Result<Vc<EcmascriptModuleContent>> {
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 generate_source_map = chunking_context.reference_module_source_maps(Vc::upcast(self));
Ok(EcmascriptModuleContent::new(
*parsed,
self.ident(),
module_type_result.module_type,
module_graph,
chunking_context,
*analyze.references,
*analyze.code_generation,
*analyze.async_module,
generate_source_map,
*analyze.source_map,
*analyze.exports,
async_module_info,
EcmascriptModuleContentOptions {
parsed,
ident: self.ident(),
specified_module_type: module_type_result.module_type,
module_graph,
chunking_context,
references: analyze.references(),
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,
async_module_info,
},
))
}
}
......@@ -590,15 +596,13 @@ impl Module for EcmascriptModuleAsset {
#[turbo_tasks::function]
async fn references(self: Vc<Self>) -> Result<Vc<ModuleReferences>> {
let analyze = self.analyze().await?;
let references = analyze.references.await?.iter().copied().collect();
Ok(Vc::cell(references))
Ok(self.analyze().references())
}
#[turbo_tasks::function]
async fn is_self_async(self: Vc<Self>) -> Result<Vc<bool>> {
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 {
Ok(Vc::cell(false))
}
......@@ -756,30 +760,43 @@ pub struct EcmascriptModuleContent {
// 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]
impl EcmascriptModuleContent {
/// Creates a new [`Vc<EcmascriptModuleContent>`].
#[turbo_tasks::function]
pub async fn new(
parsed: ResolvedVc<ParseResult>,
ident: ResolvedVc<AssetIdent>,
specified_module_type: SpecifiedModuleType,
module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
references: Vc<ModuleReferences>,
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>>,
) -> Result<Vc<Self>> {
let mut code_gen_cells = Vec::new();
for r in references.await?.iter() {
if let Some(code_gen) = ResolvedVc::try_sidecast::<Box<dyn CodeGenerateable>>(*r) {
code_gen_cells.push(code_gen.code_generation(module_graph, chunking_context));
}
}
pub async fn new(input: EcmascriptModuleContentOptions) -> Result<Vc<Self>> {
let EcmascriptModuleContentOptions {
parsed,
ident,
specified_module_type,
module_graph,
chunking_context,
references,
esm_references,
code_generation,
async_module,
generate_source_map,
original_source_map,
exports,
async_module_info,
} = input;
let additional_code_gens = [
if let Some(async_module) = &*async_module.await? {
......@@ -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
.await?
.iter()
.map(|c| c.code_generation(module_graph, chunking_context))
.try_join()
.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()
.map(|c| &**c)
.chain(additional_code_gens.iter().flatten())
.chain(code_gens.iter());
gen_content_with_code_gens(
......@@ -841,7 +862,7 @@ impl EcmascriptModuleContent {
) -> Result<Vc<Self>> {
gen_content_with_code_gens(
parsed.to_resolved().await?,
ident.to_resolved().await?,
ident,
specified_module_type,
&[],
generate_source_map,
......@@ -853,7 +874,7 @@ impl EcmascriptModuleContent {
async fn gen_content_with_code_gens(
parsed: ResolvedVc<ParseResult>,
ident: ResolvedVc<AssetIdent>,
ident: Vc<AssetIdent>,
specified_module_type: SpecifiedModuleType,
code_gens: impl IntoIterator<Item = &CodeGeneration>,
generate_source_map: Vc<bool>,
......
......@@ -33,7 +33,7 @@ use super::export::{all_known_export_names, is_export_missing};
use crate::{
analyzer::imports::ImportAnnotations,
chunk::EcmascriptChunkPlaceable,
code_gen::{CodeGenerateable, CodeGeneration},
code_gen::CodeGeneration,
magic_identifier,
references::util::{request_to_string, throw_module_not_found_expr},
runtime_functions::{TURBOPACK_EXTERNAL_IMPORT, TURBOPACK_EXTERNAL_REQUIRE, TURBOPACK_IMPORT},
......@@ -110,6 +110,9 @@ impl ReferencedAsset {
}
}
#[turbo_tasks::value(transparent)]
pub struct EsmAssetReferences(Vec<ResolvedVc<EsmAssetReference>>);
#[turbo_tasks::value(shared)]
#[derive(Hash, Debug)]
pub struct EsmAssetReference {
......@@ -252,14 +255,12 @@ impl ChunkableModuleReference for EsmAssetReference {
}
}
#[turbo_tasks::value_impl]
impl CodeGenerateable for EsmAssetReference {
#[turbo_tasks::function]
async fn code_generation(
impl EsmAssetReference {
pub async fn code_generation(
self: Vc<Self>,
module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Result<Vc<CodeGeneration>> {
) -> Result<CodeGeneration> {
let this = &*self.await?;
// only chunked references can be imported
......@@ -392,9 +393,9 @@ impl CodeGenerateable for EsmAssetReference {
};
if let Some((key, stmt)) = result {
Ok(CodeGeneration::hoisted_stmt(key, stmt).cell())
Ok(CodeGeneration::hoisted_stmt(key, stmt))
} else {
Ok(CodeGeneration::empty().cell())
Ok(CodeGeneration::empty())
}
}
}
......
......@@ -8,7 +8,7 @@ use swc_core::{
codegen::{text_writer::JsWriter, Emitter},
},
};
use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};
use turbo_tasks::{ResolvedVc, Vc};
use turbo_tasks_fs::rope::RopeBuilder;
use turbopack_core::{
chunk::{AsyncModuleInfo, ChunkItem, ChunkType, ChunkingContext},
......@@ -23,7 +23,6 @@ use crate::{
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkItemOptions,
EcmascriptChunkPlaceable, EcmascriptChunkType, EcmascriptExports,
},
code_gen::CodeGenerateable,
process_content_with_code_gens,
};
......@@ -67,21 +66,16 @@ impl EcmascriptChunkItem for EcmascriptModuleFacadeChunkItem {
let mut code = RopeBuilder::default();
let references = self.module.references();
let references_ref = references.await?;
let mut code_gens_cells = Vec::with_capacity(references_ref.len() + 2);
for r in &references_ref {
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 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,
references,
self.module.references(),
*self.module_graph,
*chunking_context,
)
......@@ -90,11 +84,7 @@ impl EcmascriptChunkItem for EcmascriptModuleFacadeChunkItem {
.code_generation(*self.module_graph, *chunking_context)
.await?,
];
let code_gen_cells = code_gens_cells.into_iter().try_join().await?;
let code_gens = code_gen_cells
.iter()
.map(|cg| &**cg)
.chain(additional_code_gens.iter());
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);
......
use std::collections::BTreeMap;
use anyhow::{bail, Result};
use turbo_tasks::{ResolvedVc, Vc};
use turbo_tasks::{ResolvedVc, TryJoinIterExt, Vc};
use turbo_tasks_fs::{glob::Glob, File, FileContent};
use turbopack_core::{
asset::{Asset, AssetContent},
......@@ -16,6 +16,7 @@ use turbopack_core::{
use super::chunk_item::EcmascriptModuleFacadeChunkItem;
use crate::{
chunk::{EcmascriptChunkPlaceable, EcmascriptExports},
code_gen::CodeGeneration,
references::{
async_module::{AsyncModule, OptionAsyncModule},
esm::{EsmExport, EsmExports},
......@@ -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]
impl Module for EcmascriptModuleFacadeModule {
#[turbo_tasks::function]
......@@ -81,14 +165,17 @@ impl Module for EcmascriptModuleFacadeModule {
);
};
let result = module.analyze().await?;
let references = result.evaluation_references;
let mut references = references.owned().await?;
references.push(ResolvedVc::upcast(
EcmascriptModulePartReference::new_part(*self.module, ModulePart::locals())
.to_resolved()
.await?,
));
references
result
.esm_evaluation_references
.await?
.iter()
.map(|r| ResolvedVc::upcast(*r))
.chain(std::iter::once(ResolvedVc::upcast(
EcmascriptModulePartReference::new_part(*self.module, ModulePart::locals())
.to_resolved()
.await?,
)))
.collect()
}
ModulePart::Exports => {
let Some(module) =
......@@ -96,18 +183,21 @@ impl Module for EcmascriptModuleFacadeModule {
else {
bail!(
"Expected EcmascriptModuleAsset for a EcmascriptModuleFacadeModule with \
ModulePart::Evaluation"
ModulePart::Exports"
);
};
let result = module.analyze().await?;
let references = result.reexport_references;
let mut references = references.owned().await?;
references.push(ResolvedVc::upcast(
EcmascriptModulePartReference::new_part(*self.module, ModulePart::locals())
.to_resolved()
.await?,
));
references
result
.esm_reexport_references
.await?
.iter()
.map(|r| ResolvedVc::upcast(*r))
.chain(std::iter::once(ResolvedVc::upcast(
EcmascriptModulePartReference::new_part(*self.module, ModulePart::locals())
.to_resolved()
.await?,
)))
.collect()
}
ModulePart::Facade => {
vec![
......
......@@ -13,7 +13,7 @@ use crate::{
EcmascriptChunkItem, EcmascriptChunkItemContent, EcmascriptChunkPlaceable,
EcmascriptChunkType,
},
EcmascriptModuleContent,
EcmascriptModuleContent, EcmascriptModuleContentOptions,
};
/// The chunk item for [EcmascriptModuleLocalsModule].
......@@ -41,9 +41,10 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem {
let module_graph = self.module_graph;
let exports = self.module.get_exports();
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
.async_module
.module_options(async_module_info);
......@@ -52,20 +53,21 @@ impl EcmascriptChunkItem for EcmascriptModuleLocalsChunkItem {
let generate_source_map =
chunking_context.reference_module_source_maps(*ResolvedVc::upcast(self.module));
let content = EcmascriptModuleContent::new(
let content = EcmascriptModuleContent::new(EcmascriptModuleContentOptions {
parsed,
self.module.ident(),
module_type_result.module_type,
*module_graph,
*chunking_context,
*analyze_result.local_references,
*analyze_result.code_generation,
*analyze_result.async_module,
ident: self.module.ident(),
specified_module_type: module_type_result.module_type,
module_graph: *module_graph,
chunking_context: *chunking_context,
references: analyze.local_references(),
esm_references: *analyze_result.esm_local_references,
code_generation: *analyze_result.code_generation,
async_module: *analyze_result.async_module,
generate_source_map,
*analyze_result.source_map,
original_source_map: analyze_result.source_map,
exports,
async_module_info,
);
});
Ok(EcmascriptChunkItemContent::new(
content,
......
......@@ -50,15 +50,15 @@ impl Module for EcmascriptModuleLocalsModule {
#[turbo_tasks::function]
async fn references(&self) -> Result<Vc<ModuleReferences>> {
let result = self.module.analyze().await?;
Ok(*result.local_references)
let result = self.module.analyze();
Ok(result.local_references())
}
#[turbo_tasks::function]
async fn is_self_async(&self) -> Result<Vc<bool>> {
let analyze = self.module.analyze().await?;
async fn is_self_async(self: Vc<Self>) -> Result<Vc<bool>> {
let analyze = self.await?.module.analyze().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)
} else {
Ok(Vc::cell(false))
......
......@@ -17,10 +17,8 @@ use super::{
facade::module::EcmascriptModuleFacadeModule, locals::module::EcmascriptModuleLocalsModule,
};
use crate::{
chunk::EcmascriptChunkPlaceable,
code_gen::{CodeGenerateable, CodeGeneration},
references::esm::base::ReferencedAsset,
runtime_functions::TURBOPACK_IMPORT,
chunk::EcmascriptChunkPlaceable, code_gen::CodeGeneration,
references::esm::base::ReferencedAsset, runtime_functions::TURBOPACK_IMPORT,
utils::module_id_to_lit,
};
......@@ -111,14 +109,12 @@ impl ChunkableModuleReference for EcmascriptModulePartReference {
}
}
#[turbo_tasks::value_impl]
impl CodeGenerateable for EcmascriptModulePartReference {
#[turbo_tasks::function]
async fn code_generation(
impl EcmascriptModulePartReference {
pub async fn code_generation(
self: Vc<Self>,
module_graph: Vc<ModuleGraph>,
chunking_context: Vc<Box<dyn ChunkingContext>>,
) -> Result<Vc<CodeGeneration>> {
) -> Result<CodeGeneration> {
let referenced_asset = ReferencedAsset::from_resolve_result(self.resolve_reference());
let referenced_asset = referenced_asset.await?;
let ident = referenced_asset
......@@ -142,7 +138,6 @@ impl CodeGenerateable for EcmascriptModulePartReference {
turbopack_import: Expr = TURBOPACK_IMPORT.into(),
id: Expr = module_id_to_lit(&id),
),
)
.cell())
))
}
}
......@@ -292,11 +292,11 @@ impl Module for EcmascriptModulePartAsset {
async fn references(&self) -> Result<Vc<ModuleReferences>> {
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 {
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>> {
......@@ -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
if self.part == ModulePart::Facade {
......
......@@ -20,7 +20,7 @@ use crate::{
runtime_functions::{TURBOPACK_EXPORT_NAMESPACE, TURBOPACK_IMPORT},
tree_shake::side_effect_module::SideEffectsModule,
utils::StringifyModuleId,
EcmascriptModuleContent,
EcmascriptModuleContent, EcmascriptModuleContentOptions,
};
/// This is an implementation of [ChunkItem] for
......@@ -49,30 +49,34 @@ impl EcmascriptChunkItem for EcmascriptModulePartChunkItem {
let module = self.module.await?;
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 async_module_options = analyze.async_module.module_options(async_module_info);
let analyze = self.module.analyze();
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 generate_source_map = self
.chunking_context
.reference_module_source_maps(*ResolvedVc::upcast(self.module));
let content = EcmascriptModuleContent::new(
let content = EcmascriptModuleContent::new(EcmascriptModuleContentOptions {
parsed,
self.module.ident(),
module_type_result.module_type,
*self.module_graph,
*self.chunking_context,
*analyze.references,
*analyze.code_generation,
*analyze.async_module,
ident: self.module.ident(),
specified_module_type: module_type_result.module_type,
module_graph: *self.module_graph,
chunking_context: *self.chunking_context,
references: analyze.references(),
esm_references: *analyze_ref.esm_references,
code_generation: *analyze_ref.code_generation,
async_module: *analyze_ref.async_module,
generate_source_map,
*analyze.source_map,
*analyze.exports,
original_source_map: analyze_ref.source_map,
exports: *analyze_ref.exports,
async_module_info,
);
});
Ok(EcmascriptChunkItemContent::new(
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