|
|
use std::{collections::BTreeMap, fmt::Write, hash::Hash, path::PathBuf, sync::Arc}; |
|
|
|
|
|
use anyhow::Error; |
|
|
use serde::Deserialize; |
|
|
use swc_core::{ |
|
|
common::{Mark, SourceMap, SyntaxContext, comments::SingleThreadedComments, util::take::Take}, |
|
|
ecma::{ |
|
|
ast::{EsVersion, Id, Module}, |
|
|
atoms::Atom, |
|
|
codegen::text_writer::JsWriter, |
|
|
parser::{EsSyntax, parse_file_as_module}, |
|
|
visit::VisitMutWith, |
|
|
}, |
|
|
testing::{self, NormalizedOutput, fixture}, |
|
|
}; |
|
|
use turbo_tasks::FxIndexSet; |
|
|
|
|
|
use super::{ |
|
|
Analyzer, Key, |
|
|
graph::{ |
|
|
DepGraph, Dependency, InternedGraph, ItemId, ItemIdGroupKind, Mode, SplitModuleResult, |
|
|
}, |
|
|
merge::Merger, |
|
|
}; |
|
|
|
|
|
#[fixture("tests/tree-shaker/analyzer/**/input.js")] |
|
|
fn test_fixture(input: PathBuf) { |
|
|
run(input); |
|
|
} |
|
|
|
|
|
#[derive(Deserialize)] |
|
|
struct TestConfig { |
|
|
|
|
|
|
|
|
#[serde(default)] |
|
|
exports: Vec<Vec<String>>, |
|
|
} |
|
|
|
|
|
fn run(input: PathBuf) { |
|
|
let config = input.with_file_name("config.json"); |
|
|
let config = std::fs::read_to_string(config).unwrap_or_else(|_| "{}".into()); |
|
|
let config = serde_json::from_str::<TestConfig>(&config).unwrap_or_else(|_e| { |
|
|
panic!("failed to parse config.json: {config}"); |
|
|
}); |
|
|
|
|
|
testing::run_test(false, |cm, _handler| { |
|
|
let fm = cm.load_file(&input).unwrap(); |
|
|
|
|
|
let comments = SingleThreadedComments::default(); |
|
|
let mut module = parse_file_as_module( |
|
|
&fm, |
|
|
swc_core::ecma::parser::Syntax::Es(EsSyntax { |
|
|
jsx: true, |
|
|
..Default::default() |
|
|
}), |
|
|
EsVersion::latest(), |
|
|
Some(&comments), |
|
|
&mut vec![], |
|
|
) |
|
|
.unwrap(); |
|
|
|
|
|
let unresolved_mark = Mark::new(); |
|
|
let top_level_mark = Mark::new(); |
|
|
let unresolved_ctxt = SyntaxContext::empty().apply_mark(unresolved_mark); |
|
|
let top_level_ctxt = SyntaxContext::empty().apply_mark(top_level_mark); |
|
|
|
|
|
module.visit_mut_with(&mut swc_core::ecma::transforms::base::resolver( |
|
|
unresolved_mark, |
|
|
top_level_mark, |
|
|
false, |
|
|
)); |
|
|
|
|
|
let mut g = DepGraph::default(); |
|
|
let (item_ids, mut items) = g.init(&module, &comments, unresolved_ctxt, top_level_ctxt); |
|
|
|
|
|
let mut s = String::new(); |
|
|
|
|
|
writeln!(s, "# Items\n").unwrap(); |
|
|
writeln!(s, "Count: {}", item_ids.len()).unwrap(); |
|
|
writeln!(s).unwrap(); |
|
|
|
|
|
for (i, id) in item_ids.iter().enumerate() { |
|
|
let item = &items[id]; |
|
|
|
|
|
let (index, kind) = match id { |
|
|
ItemId::Group(_) => continue, |
|
|
ItemId::Item { index, kind } => (*index, kind), |
|
|
}; |
|
|
|
|
|
writeln!(s, "## Item {}: Stmt {}, `{:?}`", i + 1, index, kind).unwrap(); |
|
|
writeln!(s, "\n```js\n{}\n```\n", print(&cm, &[&module.body[index]])).unwrap(); |
|
|
|
|
|
if item.is_hoisted { |
|
|
writeln!(s, "- Hoisted").unwrap(); |
|
|
} |
|
|
|
|
|
if item.side_effects { |
|
|
writeln!(s, "- Side effects").unwrap(); |
|
|
} |
|
|
|
|
|
let f = |ids: &FxIndexSet<Id>| { |
|
|
let mut s = String::new(); |
|
|
for (i, id) in ids.iter().enumerate() { |
|
|
if i == 0 { |
|
|
write!(s, "`{}`", id.0).unwrap(); |
|
|
} else { |
|
|
write!(s, ", `{}`", id.0).unwrap(); |
|
|
} |
|
|
} |
|
|
s |
|
|
}; |
|
|
|
|
|
if !item.var_decls.is_empty() { |
|
|
writeln!(s, "- Declares: {}", f(&item.var_decls)).unwrap(); |
|
|
} |
|
|
|
|
|
if !item.read_vars.is_empty() { |
|
|
writeln!(s, "- Reads: {}", f(&item.read_vars)).unwrap(); |
|
|
} |
|
|
|
|
|
if !item.eventual_read_vars.is_empty() { |
|
|
writeln!(s, "- Reads (eventual): {}", f(&item.eventual_read_vars)).unwrap(); |
|
|
} |
|
|
|
|
|
if !item.write_vars.is_empty() { |
|
|
writeln!(s, "- Write: {}", f(&item.write_vars)).unwrap(); |
|
|
} |
|
|
|
|
|
if !item.eventual_write_vars.is_empty() { |
|
|
writeln!(s, "- Write (eventual): {}", f(&item.eventual_write_vars)).unwrap(); |
|
|
} |
|
|
|
|
|
writeln!(s).unwrap(); |
|
|
} |
|
|
|
|
|
let mut analyzer = Analyzer { |
|
|
g: &mut g, |
|
|
item_ids: &item_ids, |
|
|
items: &mut items, |
|
|
last_side_effects: Default::default(), |
|
|
vars: Default::default(), |
|
|
}; |
|
|
|
|
|
let eventual_ids = analyzer.hoist_vars_and_bindings(); |
|
|
|
|
|
writeln!(s, "# Phase 1").unwrap(); |
|
|
writeln!(s, "```mermaid\n{}```", render_graph(&item_ids, analyzer.g)).unwrap(); |
|
|
|
|
|
analyzer.evaluate_immediate(&module, &eventual_ids); |
|
|
|
|
|
writeln!(s, "# Phase 2").unwrap(); |
|
|
writeln!(s, "```mermaid\n{}```", render_graph(&item_ids, analyzer.g)).unwrap(); |
|
|
|
|
|
analyzer.evaluate_eventual(&module); |
|
|
|
|
|
writeln!(s, "# Phase 3").unwrap(); |
|
|
writeln!(s, "```mermaid\n{}```", render_graph(&item_ids, analyzer.g)).unwrap(); |
|
|
|
|
|
analyzer.handle_exports(&module); |
|
|
|
|
|
writeln!(s, "# Phase 4").unwrap(); |
|
|
writeln!(s, "```mermaid\n{}```", render_graph(&item_ids, analyzer.g)).unwrap(); |
|
|
|
|
|
analyzer.handle_explicit_deps(); |
|
|
|
|
|
let mut condensed = analyzer.g.finalize(analyzer.items); |
|
|
|
|
|
writeln!(s, "# Final").unwrap(); |
|
|
writeln!( |
|
|
s, |
|
|
"```mermaid\n{}```", |
|
|
render_mermaid(&mut condensed, &|buf: &Vec<ItemId>| format!( |
|
|
"Items: {buf:?}" |
|
|
)) |
|
|
) |
|
|
.unwrap(); |
|
|
|
|
|
let uri_of_module: Atom = "entry.js".into(); |
|
|
|
|
|
let mut describe = |
|
|
|is_debug: bool, title: &str, entries: Vec<ItemIdGroupKind>, skip_parts: bool| { |
|
|
let mut g = analyzer.g.clone(); |
|
|
g.handle_weak(if is_debug { |
|
|
Mode::Development |
|
|
} else { |
|
|
Mode::Production |
|
|
}); |
|
|
let SplitModuleResult { |
|
|
modules, |
|
|
entrypoints, |
|
|
.. |
|
|
} = g.split_module(&[], analyzer.items); |
|
|
|
|
|
writeln!( |
|
|
s, |
|
|
"# Entrypoints\n\n```\n{:#?}\n```\n\n", |
|
|
|
|
|
entrypoints.iter().collect::<BTreeMap<_, _>>(), |
|
|
) |
|
|
.unwrap(); |
|
|
|
|
|
if !skip_parts { |
|
|
writeln!(s, "# Modules ({})", if is_debug { "dev" } else { "prod" }).unwrap(); |
|
|
for (i, module) in modules.iter().enumerate() { |
|
|
writeln!(s, "## Part {i}").unwrap(); |
|
|
writeln!(s, "```js\n{}\n```", print(&cm, &[module])).unwrap(); |
|
|
} |
|
|
} |
|
|
|
|
|
let mut merger = Merger::new(SingleModuleLoader { |
|
|
modules: &modules, |
|
|
entry_module_uri: &uri_of_module, |
|
|
}); |
|
|
let mut entry = Module::dummy(); |
|
|
|
|
|
for e in &entries { |
|
|
let key = match e { |
|
|
ItemIdGroupKind::ModuleEvaluation => Key::ModuleEvaluation, |
|
|
ItemIdGroupKind::Export(_, name) => Key::Export(name.as_str().into()), |
|
|
}; |
|
|
|
|
|
let index = entrypoints[&key]; |
|
|
entry.body.extend(modules[index as usize].body.clone()); |
|
|
} |
|
|
|
|
|
let module = merger.merge_recursively(entry).unwrap(); |
|
|
|
|
|
writeln!(s, "## Merged ({title})").unwrap(); |
|
|
writeln!(s, "```js\n{}\n```", print(&cm, &[&module])).unwrap(); |
|
|
}; |
|
|
describe( |
|
|
true, |
|
|
"module eval", |
|
|
vec![ItemIdGroupKind::ModuleEvaluation], |
|
|
false, |
|
|
); |
|
|
describe( |
|
|
false, |
|
|
"module eval", |
|
|
vec![ItemIdGroupKind::ModuleEvaluation], |
|
|
false, |
|
|
); |
|
|
|
|
|
for exports in config.exports { |
|
|
describe( |
|
|
false, |
|
|
&exports.join(","), |
|
|
exports |
|
|
.into_iter() |
|
|
.map(|e| ItemIdGroupKind::Export(((*e).into(), Default::default()), e.into())) |
|
|
.collect(), |
|
|
true, |
|
|
); |
|
|
} |
|
|
|
|
|
NormalizedOutput::from(s) |
|
|
.compare_to_file(input.with_file_name("output.md")) |
|
|
.unwrap(); |
|
|
|
|
|
Ok(()) |
|
|
}) |
|
|
.unwrap(); |
|
|
} |
|
|
|
|
|
struct SingleModuleLoader<'a> { |
|
|
entry_module_uri: &'a str, |
|
|
modules: &'a [Module], |
|
|
} |
|
|
|
|
|
impl super::merge::Load for SingleModuleLoader<'_> { |
|
|
fn load(&mut self, uri: &str, chunk_id: u32) -> Result<Option<Module>, Error> { |
|
|
if self.entry_module_uri == uri { |
|
|
return Ok(Some(self.modules[chunk_id as usize].clone())); |
|
|
} |
|
|
|
|
|
Ok(None) |
|
|
} |
|
|
} |
|
|
|
|
|
fn print<N: swc_core::ecma::codegen::Node>(cm: &Arc<SourceMap>, nodes: &[&N]) -> String { |
|
|
let mut buf = vec![]; |
|
|
|
|
|
{ |
|
|
let mut emitter = swc_core::ecma::codegen::Emitter { |
|
|
cfg: swc_core::ecma::codegen::Config::default() |
|
|
.with_emit_assert_for_import_attributes(true), |
|
|
cm: cm.clone(), |
|
|
comments: None, |
|
|
wr: Box::new(JsWriter::new(cm.clone(), "\n", &mut buf, None)), |
|
|
}; |
|
|
|
|
|
for n in nodes { |
|
|
n.emit_with(&mut emitter).unwrap(); |
|
|
} |
|
|
} |
|
|
|
|
|
String::from_utf8(buf).unwrap() |
|
|
} |
|
|
|
|
|
fn render_graph(item_ids: &[ItemId], g: &mut DepGraph) -> String { |
|
|
let mut mermaid = String::from("graph TD\n"); |
|
|
|
|
|
for id in item_ids.iter() { |
|
|
let i = g.g.node(id); |
|
|
|
|
|
writeln!(mermaid, " Item{};", i + 1).unwrap(); |
|
|
|
|
|
if let Some(item_id) = render_item_id(id) { |
|
|
writeln!(mermaid, " Item{}[\"{}\"];", i + 1, item_id).unwrap(); |
|
|
} |
|
|
} |
|
|
|
|
|
for (from, to, kind) in g.g.idx_graph.all_edges() { |
|
|
writeln!( |
|
|
mermaid, |
|
|
" Item{} -{}-> Item{};", |
|
|
from + 1, |
|
|
match kind { |
|
|
Dependency::Strong => "", |
|
|
Dependency::Weak => ".", |
|
|
}, |
|
|
to + 1, |
|
|
) |
|
|
.unwrap(); |
|
|
} |
|
|
|
|
|
mermaid |
|
|
} |
|
|
|
|
|
fn render_mermaid<T>(g: &mut InternedGraph<T>, render: &dyn Fn(&T) -> String) -> String |
|
|
where |
|
|
T: Clone + Eq + Hash, |
|
|
{ |
|
|
let mut mermaid = String::from("graph TD\n"); |
|
|
let ix = g.graph_ix.clone(); |
|
|
|
|
|
for item in &ix { |
|
|
let i = g.node(item); |
|
|
|
|
|
writeln!( |
|
|
mermaid, |
|
|
" N{}[\"{}\"];", |
|
|
i, |
|
|
render(item).replace([';', '\n'], "").replace('"', """) |
|
|
) |
|
|
.unwrap(); |
|
|
} |
|
|
|
|
|
for (from, to, kind) in g.idx_graph.all_edges() { |
|
|
writeln!( |
|
|
mermaid, |
|
|
" N{} -{}-> N{};", |
|
|
from, |
|
|
match kind { |
|
|
Dependency::Strong => "", |
|
|
Dependency::Weak => ".", |
|
|
}, |
|
|
to, |
|
|
) |
|
|
.unwrap(); |
|
|
} |
|
|
|
|
|
mermaid |
|
|
} |
|
|
|
|
|
fn render_item_id(id: &ItemId) -> Option<String> { |
|
|
match id { |
|
|
ItemId::Group(ItemIdGroupKind::ModuleEvaluation) => Some("ModuleEvaluation".into()), |
|
|
ItemId::Group(ItemIdGroupKind::Export(_, name)) => Some(format!("export {name}")), |
|
|
_ => None, |
|
|
} |
|
|
} |
|
|
|
