From c3d89be208332396d218fbbeced0b6e35c800f5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Tue, 18 Jun 2024 09:48:05 +0900 Subject: [PATCH 001/154] WIP: Print input --- .../src/tree_shake/mod.rs | 29 +++++++++++++++++-- 1 file changed, 26 insertions(+), 3 deletions(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/mod.rs b/crates/turbopack-ecmascript/src/tree_shake/mod.rs index c72b11ecfc1ab..655d368613b31 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/mod.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/mod.rs @@ -5,9 +5,12 @@ use indexmap::IndexSet; use rustc_hash::FxHashMap; use swc_core::{ common::{util::take::Take, SyntaxContext, DUMMY_SP, GLOBALS}, - ecma::ast::{ - ExportNamedSpecifier, Id, Ident, ImportDecl, Module, ModuleDecl, ModuleExportName, - ModuleItem, NamedExport, Program, + ecma::{ + ast::{ + ExportNamedSpecifier, Id, Ident, ImportDecl, Module, ModuleDecl, ModuleExportName, + ModuleItem, NamedExport, Program, + }, + codegen::{text_writer::JsWriter, Emitter}, }, }; use turbo_tasks::{RcStr, ValueToString, Vc}; @@ -400,6 +403,26 @@ pub(super) async fn split( .cell()); } + { + let mut buf = vec![]; + + { + let wr = JsWriter::new(Default::default(), "\n", &mut buf, None); + + let mut emitter = Emitter { + cfg: Default::default(), + comments: None, + cm: source_map.clone(), + wr, + }; + + emitter.emit_program(program).unwrap(); + } + let code = String::from_utf8(buf).unwrap(); + + println!("# Program:\n{code}"); + } + let module = match program { Program::Module(module) => module, Program::Script(..) => unreachable!("CJS is already handled"), From 6b75f6c31dddd0f46bc33d2b5ce53c64512cc204 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Tue, 18 Jun 2024 09:52:09 +0900 Subject: [PATCH 002/154] Add a test --- .../tests/tree-shaker/analyzer/jsx-dev-1/input.js | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 crates/turbopack-ecmascript/tests/tree-shaker/analyzer/jsx-dev-1/input.js diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/jsx-dev-1/input.js b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/jsx-dev-1/input.js new file mode 100644 index 0000000000000..492e6c63432a3 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/jsx-dev-1/input.js @@ -0,0 +1,8 @@ +import { jsxDEV as _jsxDEV } from "react/jsx-dev-runtime"; +export default ()=>_jsxDEV("div", { + children: "Hello World" + }, void 0, false, { + fileName: "[project]/test/integration/dist-dir/pages/index.js", + lineNumber: 1, + columnNumber: 22 + }, this); From 0ec839eadd1a50e778fe2e925008eb9c0eff4b9e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Tue, 18 Jun 2024 09:54:47 +0900 Subject: [PATCH 003/154] Print the split result --- .../src/tree_shake/mod.rs | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/crates/turbopack-ecmascript/src/tree_shake/mod.rs b/crates/turbopack-ecmascript/src/tree_shake/mod.rs index 655d368613b31..8e2eca336d5f1 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/mod.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/mod.rs @@ -444,6 +444,25 @@ pub(super) async fn split( modules, } = dep_graph.split_module(&items); + for (i, m) in modules.iter().enumerate() { + let mut buf = vec![]; + + { + let wr = JsWriter::new(Default::default(), "\n", &mut buf, None); + + let mut emitter = Emitter { + cfg: Default::default(), + comments: None, + cm: source_map.clone(), + wr, + }; + + emitter.emit_module(m).unwrap(); + } + let code = String::from_utf8(buf).unwrap(); + + println!("# Module #{i}:\n{code}"); + } assert_ne!(modules.len(), 0, "modules.len() == 0;\nModule: {module:?}",); for &v in entrypoints.values() { From 330d378c1c34c0d60b05c65172e78608934aa56c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Tue, 18 Jun 2024 09:55:02 +0900 Subject: [PATCH 004/154] Remove useless unit test --- .../tests/tree-shaker/analyzer/jsx-dev-1/input.js | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 crates/turbopack-ecmascript/tests/tree-shaker/analyzer/jsx-dev-1/input.js diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/jsx-dev-1/input.js b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/jsx-dev-1/input.js deleted file mode 100644 index 492e6c63432a3..0000000000000 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/jsx-dev-1/input.js +++ /dev/null @@ -1,8 +0,0 @@ -import { jsxDEV as _jsxDEV } from "react/jsx-dev-runtime"; -export default ()=>_jsxDEV("div", { - children: "Hello World" - }, void 0, false, { - fileName: "[project]/test/integration/dist-dir/pages/index.js", - lineNumber: 1, - columnNumber: 22 - }, this); From bd250f54c5b624a0ff468cbb75d649ac924fc096 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Tue, 18 Jun 2024 10:31:08 +0900 Subject: [PATCH 005/154] top_level_vars --- .../src/tree_shake/graph.rs | 63 +++++-- .../src/tree_shake/util.rs | 160 ++++++++++++++++-- 2 files changed, 192 insertions(+), 31 deletions(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/graph.rs b/crates/turbopack-ecmascript/src/tree_shake/graph.rs index 9531033047db0..4da9cafec6afc 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/graph.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/graph.rs @@ -26,7 +26,7 @@ use swc_core::{ use turbo_tasks::RcStr; use super::{ - util::{ids_captured_by, ids_used_by, ids_used_by_ignoring_nested}, + util::{collect_top_level_decls, ids_captured_by, ids_used_by, ids_used_by_ignoring_nested}, Key, TURBOPACK_PART_IMPORT_SOURCE, }; use crate::magic_identifier; @@ -557,6 +557,7 @@ impl DepGraph { unresolved_ctxt: SyntaxContext, top_level_ctxt: SyntaxContext, ) -> (Vec, FxHashMap) { + let top_level_vars = collect_top_level_decls(module); let mut exports = vec![]; let mut items = FxHashMap::default(); let mut ids = vec![]; @@ -701,10 +702,15 @@ impl DepGraph { &export.decl, unresolved_ctxt, top_level_ctxt, + &top_level_vars, ); used_ids.write.insert(default_var.to_id()); - let captured_ids = - ids_captured_by(&export.decl, unresolved_ctxt, top_level_ctxt); + let captured_ids = ids_captured_by( + &export.decl, + unresolved_ctxt, + top_level_ctxt, + &top_level_vars, + ); let data = ItemData { read_vars: used_ids.read, eventual_read_vars: captured_ids.read, @@ -741,9 +747,14 @@ impl DepGraph { &export.expr, unresolved_ctxt, top_level_ctxt, + &top_level_vars, + ); + let captured_ids = ids_captured_by( + &export.expr, + unresolved_ctxt, + top_level_ctxt, + &top_level_vars, ); - let captured_ids = - ids_captured_by(&export.expr, unresolved_ctxt, top_level_ctxt); used_ids.write.insert(default_var.to_id()); @@ -875,7 +886,12 @@ impl DepGraph { }; ids.push(id.clone()); - let vars = ids_used_by(&f.function, unresolved_ctxt, top_level_ctxt); + let vars = ids_used_by( + &f.function, + unresolved_ctxt, + top_level_ctxt, + &top_level_vars, + ); let var_decls = { let mut v = IndexSet::with_capacity_and_hasher(1, Default::default()); v.insert(f.ident.to_id()); @@ -905,7 +921,8 @@ impl DepGraph { }; ids.push(id.clone()); - let vars = ids_used_by(&c.class, unresolved_ctxt, top_level_ctxt); + let vars = + ids_used_by(&c.class, unresolved_ctxt, top_level_ctxt, &top_level_vars); let var_decls = { let mut v = IndexSet::with_capacity_and_hasher(1, Default::default()); v.insert(c.ident.to_id()); @@ -941,9 +958,14 @@ impl DepGraph { &decl.init, unresolved_ctxt, top_level_ctxt, + &top_level_vars, + ); + let eventual_vars = ids_captured_by( + &decl.init, + unresolved_ctxt, + top_level_ctxt, + &top_level_vars, ); - let eventual_vars = - ids_captured_by(&decl.init, unresolved_ctxt, top_level_ctxt); let side_effects = vars.found_unresolved; @@ -972,9 +994,14 @@ impl DepGraph { expr: box Expr::Assign(assign), .. })) => { - let mut used_ids = - ids_used_by_ignoring_nested(item, unresolved_ctxt, top_level_ctxt); - let captured_ids = ids_captured_by(item, unresolved_ctxt, top_level_ctxt); + let mut used_ids = ids_used_by_ignoring_nested( + item, + unresolved_ctxt, + top_level_ctxt, + &top_level_vars, + ); + let captured_ids = + ids_captured_by(item, unresolved_ctxt, top_level_ctxt, &top_level_vars); if assign.op != op!("=") { used_ids.read.extend(used_ids.write.iter().cloned()); @@ -983,6 +1010,7 @@ impl DepGraph { &assign.left, unresolved_ctxt, top_level_ctxt, + &top_level_vars, ); used_ids.read.extend(extra_ids.read); used_ids.write.extend(extra_ids.write); @@ -1017,9 +1045,14 @@ impl DepGraph { _ => { // Default to normal - let used_ids = - ids_used_by_ignoring_nested(item, unresolved_ctxt, top_level_ctxt); - let captured_ids = ids_captured_by(item, unresolved_ctxt, top_level_ctxt); + let used_ids = ids_used_by_ignoring_nested( + item, + unresolved_ctxt, + top_level_ctxt, + &top_level_vars, + ); + let captured_ids = + ids_captured_by(item, unresolved_ctxt, top_level_ctxt, &top_level_vars); let data = ItemData { read_vars: used_ids.read, eventual_read_vars: captured_ids.read, diff --git a/crates/turbopack-ecmascript/src/tree_shake/util.rs b/crates/turbopack-ecmascript/src/tree_shake/util.rs index 79224046c7dd7..d41ba35e4024b 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/util.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/util.rs @@ -1,13 +1,15 @@ use std::hash::BuildHasherDefault; use indexmap::IndexSet; -use rustc_hash::FxHasher; +use rustc_hash::{FxHashSet, FxHasher}; use swc_core::{ common::SyntaxContext, ecma::{ ast::{ - AssignTarget, BlockStmtOrExpr, Constructor, ExportNamedSpecifier, ExportSpecifier, - Expr, Function, Id, Ident, MemberExpr, MemberProp, NamedExport, Pat, PropName, + ArrowExpr, AssignPatProp, AssignTarget, BlockStmtOrExpr, ClassDecl, ClassExpr, + Constructor, DefaultDecl, ExportDefaultDecl, ExportNamedSpecifier, ExportSpecifier, + Expr, FnDecl, FnExpr, Function, Id, Ident, ImportSpecifier, MemberExpr, MemberProp, + NamedExport, Param, Pat, PropName, VarDeclarator, }, visit::{noop_visit_type, Visit, VisitWith}, }, @@ -27,10 +29,11 @@ struct Target { } /// A visitor which collects variables which are read or written. -#[derive(Default)] -pub(crate) struct IdentUsageCollector { +pub(crate) struct IdentUsageCollector<'a> { unresolved: SyntaxContext, top_level: SyntaxContext, + top_level_vars: &'a FxHashSet, + vars: Vars, is_nested: bool, @@ -39,7 +42,7 @@ pub(crate) struct IdentUsageCollector { mode: Option, } -impl IdentUsageCollector { +impl IdentUsageCollector<'_> { fn with_nested(&mut self, f: impl FnOnce(&mut Self)) { if !self.target.eventual { return; @@ -58,7 +61,7 @@ impl IdentUsageCollector { } } -impl Visit for IdentUsageCollector { +impl Visit for IdentUsageCollector<'_> { fn visit_assign_target(&mut self, n: &AssignTarget) { self.with_mode(Some(Mode::Write), |this| { n.visit_children_with(this); @@ -114,6 +117,7 @@ impl Visit for IdentUsageCollector { if n.span.ctxt != self.unresolved && n.span.ctxt != self.top_level && n.span.ctxt != SyntaxContext::empty() + && !self.top_level_vars.contains(&n.to_id()) { return; } @@ -186,18 +190,26 @@ pub(crate) struct Vars { /// /// Note: This functions accept `SyntaxContext` to filter out variables which /// are not interesting. We only need to analyze top-level variables. -pub(crate) fn ids_captured_by(n: &N, unresolved: SyntaxContext, top_level: SyntaxContext) -> Vars +pub(crate) fn ids_captured_by<'a, N>( + n: &N, + unresolved: SyntaxContext, + top_level: SyntaxContext, + top_level_vars: &'a FxHashSet, +) -> Vars where - N: VisitWith, + N: VisitWith>, { let mut v = IdentUsageCollector { unresolved, top_level, + top_level_vars, target: Target { direct: false, eventual: true, }, - ..Default::default() + vars: Vars::default(), + is_nested: false, + mode: None, }; n.visit_with(&mut v); v.vars @@ -207,18 +219,26 @@ where /// /// Note: This functions accept `SyntaxContext` to filter out variables which /// are not interesting. We only need to analyze top-level variables. -pub(crate) fn ids_used_by(n: &N, unresolved: SyntaxContext, top_level: SyntaxContext) -> Vars +pub(crate) fn ids_used_by<'a, N>( + n: &N, + unresolved: SyntaxContext, + top_level: SyntaxContext, + top_level_vars: &'a FxHashSet, +) -> Vars where - N: VisitWith, + N: VisitWith>, { let mut v = IdentUsageCollector { unresolved, top_level, + top_level_vars, target: Target { direct: true, eventual: true, }, - ..Default::default() + vars: Vars::default(), + is_nested: false, + mode: None, }; n.visit_with(&mut v); v.vars @@ -228,23 +248,131 @@ where /// /// Note: This functions accept `SyntaxContext` to filter out variables which /// are not interesting. We only need to analyze top-level variables. -pub(crate) fn ids_used_by_ignoring_nested( +pub(crate) fn ids_used_by_ignoring_nested<'a, N>( n: &N, unresolved: SyntaxContext, top_level: SyntaxContext, + top_level_vars: &'a FxHashSet, ) -> Vars where - N: VisitWith, + N: VisitWith>, { let mut v = IdentUsageCollector { unresolved, top_level, + top_level_vars, target: Target { direct: true, eventual: false, }, - ..Default::default() + vars: Vars::default(), + is_nested: false, + mode: None, }; n.visit_with(&mut v); v.vars } + +pub struct TopLevelBindingCollector { + bindings: FxHashSet, + is_pat_decl: bool, +} + +impl TopLevelBindingCollector { + fn add(&mut self, i: &Ident) { + self.bindings.insert(i.to_id()); + } +} + +impl Visit for TopLevelBindingCollector { + noop_visit_type!(); + + fn visit_arrow_expr(&mut self, _: &ArrowExpr) {} + + fn visit_assign_pat_prop(&mut self, node: &AssignPatProp) { + node.value.visit_with(self); + + if self.is_pat_decl { + self.add(&node.key); + } + } + + fn visit_class_decl(&mut self, node: &ClassDecl) { + self.add(&node.ident); + } + + fn visit_expr(&mut self, _: &Expr) {} + + fn visit_export_default_decl(&mut self, e: &ExportDefaultDecl) { + match &e.decl { + DefaultDecl::Class(ClassExpr { + ident: Some(ident), .. + }) => { + self.add(ident); + } + DefaultDecl::Fn(FnExpr { + ident: Some(ident), + function: f, + }) if f.body.is_some() => { + self.add(ident); + } + _ => {} + } + } + + fn visit_fn_decl(&mut self, node: &FnDecl) { + self.add(&node.ident); + } + + fn visit_import_specifier(&mut self, node: &ImportSpecifier) { + match node { + ImportSpecifier::Named(s) => self.add(&s.local), + ImportSpecifier::Default(s) => { + self.add(&s.local); + } + ImportSpecifier::Namespace(s) => { + self.add(&s.local); + } + } + } + + fn visit_param(&mut self, node: &Param) { + let old = self.is_pat_decl; + self.is_pat_decl = true; + node.visit_children_with(self); + self.is_pat_decl = old; + } + + fn visit_pat(&mut self, node: &Pat) { + node.visit_children_with(self); + + if self.is_pat_decl { + if let Pat::Ident(i) = node { + self.add(&i.id) + } + } + } + + fn visit_var_declarator(&mut self, node: &VarDeclarator) { + let old = self.is_pat_decl; + self.is_pat_decl = true; + node.name.visit_with(self); + + self.is_pat_decl = false; + node.init.visit_with(self); + self.is_pat_decl = old; + } +} + +/// Collects binding identifiers. +pub fn collect_top_level_decls(n: &N) -> FxHashSet +where + N: VisitWith, +{ + let mut v = TopLevelBindingCollector { + bindings: Default::default(), + is_pat_decl: false, + }; + n.visit_with(&mut v); + v.bindings +} From 4e06e0a363f4dd35c28eacbc965f6bee96dd1876 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Tue, 18 Jun 2024 11:16:44 +0900 Subject: [PATCH 006/154] dump module on failure --- .../src/tree_shake/mod.rs | 47 +++++++++++++++++-- 1 file changed, 42 insertions(+), 5 deletions(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/mod.rs b/crates/turbopack-ecmascript/src/tree_shake/mod.rs index 8e2eca336d5f1..225537842e113 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/mod.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/mod.rs @@ -1,4 +1,4 @@ -use std::borrow::Cow; +use std::{borrow::Cow, fmt::Write}; use anyhow::{bail, Result}; use indexmap::IndexSet; @@ -325,16 +325,53 @@ async fn get_part_id(result: &SplitResult, part: Vc) -> Result } }; - let entrypoints = match &result { - SplitResult::Ok { entrypoints, .. } => entrypoints, - _ => bail!("split failed"), + let SplitResult::Ok { + entrypoints, + modules, + .. + } = &result + else { + bail!("split failed") }; let part_id = match entrypoints.get(&key) { Some(id) => *id, None => { + let mut dump = String::new(); + + for (idx, m) in modules.iter().enumerate() { + let ParseResult::Ok { + program, + source_map, + .. + } = &*m.await? + else { + bail!("failed to get module") + }; + + { + let mut buf = vec![]; + + { + let wr = JsWriter::new(Default::default(), "\n", &mut buf, None); + + let mut emitter = Emitter { + cfg: Default::default(), + comments: None, + cm: source_map.clone(), + wr, + }; + + emitter.emit_program(program).unwrap(); + } + let code = String::from_utf8(buf).unwrap(); + + writeln!(dump, "# Module #{idx}:\n{code}\n\n\n")?; + } + } + bail!( - "could not find part id for module part {:?} in {:?}", + "could not find part id for module part {:?} in {:?}\n\nModule dump:\n{dump}", key, entrypoints ) From 5e2f16b9d146389c5ff011f10b0480026f6a2794 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Tue, 18 Jun 2024 11:39:53 +0900 Subject: [PATCH 007/154] export * --- crates/turbopack-ecmascript/src/tree_shake/mod.rs | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/mod.rs b/crates/turbopack-ecmascript/src/tree_shake/mod.rs index 225537842e113..ab5b48c30f4ba 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/mod.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/mod.rs @@ -335,8 +335,15 @@ async fn get_part_id(result: &SplitResult, part: Vc) -> Result }; let part_id = match entrypoints.get(&key) { - Some(id) => *id, + Some(&id) => id, None => { + // This is required to handle `export * from 'foo'` + if let ModulePart::Export(..) = &*part { + if let Some(&v) = entrypoints.get(&key) { + return Ok(v); + } + } + let mut dump = String::new(); for (idx, m) in modules.iter().enumerate() { From e53f2e4f58b2c478f65c5ddf23af88f1f4be5eef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Tue, 18 Jun 2024 11:41:16 +0900 Subject: [PATCH 008/154] fixup --- crates/turbopack-ecmascript/src/tree_shake/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/mod.rs b/crates/turbopack-ecmascript/src/tree_shake/mod.rs index ab5b48c30f4ba..e029eee722d30 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/mod.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/mod.rs @@ -339,7 +339,7 @@ async fn get_part_id(result: &SplitResult, part: Vc) -> Result None => { // This is required to handle `export * from 'foo'` if let ModulePart::Export(..) = &*part { - if let Some(&v) = entrypoints.get(&key) { + if let Some(&v) = entrypoints.get(&Key::ModuleEvaluation) { return Ok(v); } } From f325ac948384ebfb38500a6e4285b53235690054 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 14:41:16 +0900 Subject: [PATCH 009/154] Add a test --- .../tests/tree-shaker/analyzer/node-fetch/input.js | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 crates/turbopack-ecmascript/tests/tree-shaker/analyzer/node-fetch/input.js diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/node-fetch/input.js b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/node-fetch/input.js new file mode 100644 index 0000000000000..dbdeaab4b2c2a --- /dev/null +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/node-fetch/input.js @@ -0,0 +1,9 @@ +import Stream from 'node:stream'; + +const streamDestructionSupported = 'destroy' in Stream.Readable.prototype; + +function fetch(){ + +} + +export default fetch; From 906ee3cb00208f42839746ec155a211495c582d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 14:42:30 +0900 Subject: [PATCH 010/154] Update test refs --- .../tree-shaker/analyzer/node-fetch/output.md | 260 ++++++++++++++++++ 1 file changed, 260 insertions(+) create mode 100644 crates/turbopack-ecmascript/tests/tree-shaker/analyzer/node-fetch/output.md diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/node-fetch/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/node-fetch/output.md new file mode 100644 index 0000000000000..6c18e330b2aae --- /dev/null +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/node-fetch/output.md @@ -0,0 +1,260 @@ +# Items + +Count: 7 + +## Item 1: Stmt 0, `ImportOfModule` + +```js +import Stream from 'node:stream'; + +``` + +- Hoisted +- Side effects + +## Item 2: Stmt 0, `ImportBinding(0)` + +```js +import Stream from 'node:stream'; + +``` + +- Hoisted +- Declares: `Stream` + +## Item 3: Stmt 1, `VarDeclarator(0)` + +```js +const streamDestructionSupported = 'destroy' in Stream.Readable.prototype; + +``` + +- Declares: `streamDestructionSupported` +- Reads: `Stream` +- Write: `streamDestructionSupported`, `Stream` + +## Item 4: Stmt 2, `Normal` + +```js +function fetch() {} + +``` + +- Hoisted +- Declares: `fetch` +- Write: `fetch` + +## Item 5: Stmt 3, `Normal` + +```js +export default fetch; + +``` + +- Side effects +- Declares: `__TURBOPACK__default__export__` +- Reads: `fetch` +- Write: `__TURBOPACK__default__export__` + +# Phase 1 +```mermaid +graph TD + Item1; + Item2; + Item3; + Item4; + Item5; + Item6; + Item6["ModuleEvaluation"]; + Item7; + Item7["export default"]; +``` +# Phase 2 +```mermaid +graph TD + Item1; + Item2; + Item3; + Item4; + Item5; + Item6; + Item6["ModuleEvaluation"]; + Item7; + Item7["export default"]; + Item3 --> Item2; + Item5 --> Item4; + Item5 --> Item1; +``` +# Phase 3 +```mermaid +graph TD + Item1; + Item2; + Item3; + Item4; + Item5; + Item6; + Item6["ModuleEvaluation"]; + Item7; + Item7["export default"]; + Item3 --> Item2; + Item5 --> Item4; + Item5 --> Item1; +``` +# Phase 4 +```mermaid +graph TD + Item1; + Item2; + Item3; + Item4; + Item5; + Item6; + Item6["ModuleEvaluation"]; + Item7; + Item7["export default"]; + Item3 --> Item2; + Item5 --> Item4; + Item5 --> Item1; + Item6 --> Item1; + Item6 --> Item5; + Item7 --> Item5; +``` +# Final +```mermaid +graph TD + N0["Items: [ItemId(ModuleEvaluation)]"]; + N1["Items: [ItemId(Export(("__TURBOPACK__default__export__", #4), "default"))]"]; + N2["Items: [ItemId(0, ImportOfModule)]"]; + N3["Items: [ItemId(2, Normal), ItemId(3, Normal)]"]; + N0 --> N2; + N0 --> N3; + N1 --> N3; + N3 --> N2; +``` +# Entrypoints + +``` +{ + ModuleEvaluation: 0, + Export( + "default", + ): 1, +} +``` + + +# Modules (dev) +## Part 0 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +"module evaluation"; + +``` +## Part 1 +```js +import { __TURBOPACK__default__export__ } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +export { __TURBOPACK__default__export__ as default }; + +``` +## Part 2 +```js +import 'node:stream'; + +``` +## Part 3 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +function fetch() {} +const __TURBOPACK__default__export__ = fetch; +export { fetch } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { __TURBOPACK__default__export__ } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Merged (module eval) +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +"module evaluation"; + +``` +# Entrypoints + +``` +{ + ModuleEvaluation: 0, + Export( + "default", + ): 1, +} +``` + + +# Modules (prod) +## Part 0 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +"module evaluation"; + +``` +## Part 1 +```js +import { __TURBOPACK__default__export__ } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +export { __TURBOPACK__default__export__ as default }; + +``` +## Part 2 +```js +import 'node:stream'; + +``` +## Part 3 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +function fetch() {} +const __TURBOPACK__default__export__ = fetch; +export { fetch } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { __TURBOPACK__default__export__ } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Merged (module eval) +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +"module evaluation"; + +``` From 6f33da390848d826353d5e84bbd03f7bba5903f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 14:43:53 +0900 Subject: [PATCH 011/154] cleanup --- crates/turbopack-ecmascript/src/tree_shake/graph.rs | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/graph.rs b/crates/turbopack-ecmascript/src/tree_shake/graph.rs index 4da9cafec6afc..dc0003e614f24 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/graph.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/graph.rs @@ -854,11 +854,7 @@ impl DepGraph { kind: ItemIdItemKind::ImportBinding(si as _), }; ids.push(id.clone()); - let local = match s { - ImportSpecifier::Named(s) => s.local.to_id(), - ImportSpecifier::Default(s) => s.local.to_id(), - ImportSpecifier::Namespace(s) => s.local.to_id(), - }; + let local = s.local().to_id(); items.insert( id, ItemData { From 7261365ddad3f9e16b4e32e46b2b2cdc413b663e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 14:46:48 +0900 Subject: [PATCH 012/154] required_vars --- crates/turbopack-ecmascript/src/tree_shake/graph.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/graph.rs b/crates/turbopack-ecmascript/src/tree_shake/graph.rs index dc0003e614f24..6020faaa0d487 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/graph.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/graph.rs @@ -295,7 +295,7 @@ impl DepGraph { let data = data.get(dep_item).unwrap(); for var in data.var_decls.iter() { - if required_vars.remove(var) { + if required_vars.contains(var) { specifiers.push(ImportSpecifier::Named(ImportNamedSpecifier { span: DUMMY_SP, local: var.clone().into(), From 06b85a0bb589f4fdc907d54948b5b136d5c87a37 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 14:52:33 +0900 Subject: [PATCH 013/154] Remove wrong optimization --- crates/turbopack-ecmascript/src/tree_shake/mod.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/mod.rs b/crates/turbopack-ecmascript/src/tree_shake/mod.rs index e029eee722d30..4ce013d8e2d19 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/mod.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/mod.rs @@ -205,9 +205,10 @@ impl Analyzer<'_> { // Optimization: Remove each module item to which we // just created a strong dependency from LAST_WRITES - state - .last_writes - .retain(|last_write| !self.g.has_dep(item_id, last_write, true)); + // state + // .last_writes + // .retain(|last_write| !self.g.has_dep(item_id, + // last_write, true)); // Drop all writes which are not reachable from this item. // From 52de4ad45488c50fa2c1e2f41639aa33db89f852 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 14:53:05 +0900 Subject: [PATCH 014/154] Update test refs --- .../tests/tree-shaker/analyzer/1/output.md | 126 +++++-- .../tests/tree-shaker/analyzer/2/output.md | 126 +++++-- .../tree-shaker/analyzer/complex/output.md | 198 +++++++--- .../tree-shaker/analyzer/failed-2/output.md | 46 ++- .../tree-shaker/analyzer/grouping/output.md | 353 ++++++++++++++++-- .../tree-shaker/analyzer/route-kind/output.md | 20 +- .../tree-shaker/analyzer/shared-2/output.md | 80 ++-- .../analyzer/shared-regression/output.md | 80 ++-- .../analyzer/test-config-1/output.md | 138 +++++-- .../analyzer/write-order/output.md | 121 ++++-- 10 files changed, 997 insertions(+), 291 deletions(-) diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/1/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/1/output.md index 66a2680795ce9..5b64852df2606 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/1/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/1/output.md @@ -203,22 +203,25 @@ graph TD Item6 --> Item5; Item6 --> Item3; Item6 -.-> Item4; - Item7 --> Item6; Item7 --> Item3; - Item8 --> Item6; + Item7 --> Item6; Item8 --> Item3; + Item8 --> Item6; Item8 -.-> Item4; Item8 -.-> Item7; Item9 --> Item7; Item9 --> Item1; Item9 -.-> Item2; + Item9 -.-> Item3; + Item9 -.-> Item6; Item9 -.-> Item8; Item9 -.-> Item4; Item9 -.-> Item11; Item10 --> Item7; Item10 -.-> Item9; - Item15 --> Item8; Item15 --> Item3; + Item15 --> Item6; + Item15 --> Item8; Item16 --> Item4; Item17 --> Item12; Item18 --> Item13; @@ -253,28 +256,35 @@ graph TD Item6 --> Item5; Item6 --> Item3; Item6 -.-> Item4; - Item7 --> Item6; Item7 --> Item3; - Item8 --> Item6; + Item7 --> Item6; Item8 --> Item3; + Item8 --> Item6; Item8 -.-> Item4; Item8 -.-> Item7; Item9 --> Item7; Item9 --> Item1; Item9 -.-> Item2; + Item9 -.-> Item3; + Item9 -.-> Item6; Item9 -.-> Item8; Item9 -.-> Item4; Item9 -.-> Item11; Item10 --> Item7; Item10 -.-> Item9; - Item15 --> Item8; Item15 --> Item3; + Item15 --> Item6; + Item15 --> Item8; Item16 --> Item4; Item17 --> Item12; Item18 --> Item13; Item11 --> Item2; + Item11 --> Item3; + Item11 --> Item6; Item11 --> Item8; Item12 --> Item11; + Item12 --> Item3; + Item12 --> Item6; Item12 --> Item8; Item13 -.-> Item4; Item13 -.-> Item7; @@ -310,28 +320,35 @@ graph TD Item6 --> Item5; Item6 --> Item3; Item6 -.-> Item4; - Item7 --> Item6; Item7 --> Item3; - Item8 --> Item6; + Item7 --> Item6; Item8 --> Item3; + Item8 --> Item6; Item8 -.-> Item4; Item8 -.-> Item7; Item9 --> Item7; Item9 --> Item1; Item9 -.-> Item2; + Item9 -.-> Item3; + Item9 -.-> Item6; Item9 -.-> Item8; Item9 -.-> Item4; Item9 -.-> Item11; Item10 --> Item7; Item10 -.-> Item9; - Item15 --> Item8; Item15 --> Item3; + Item15 --> Item6; + Item15 --> Item8; Item16 --> Item4; Item17 --> Item12; Item18 --> Item13; Item11 --> Item2; + Item11 --> Item3; + Item11 --> Item6; Item11 --> Item8; Item12 --> Item11; + Item12 --> Item3; + Item12 --> Item6; Item12 --> Item8; Item13 -.-> Item4; Item13 -.-> Item7; @@ -355,12 +372,17 @@ graph TD N10["Items: [ItemId(0, ImportBinding(0)), ItemId(9, Normal)]"]; N0 --> N8; N0 --> N10; + N0 --> N5; + N0 --> N7; N0 --> N9; N0 --> N6; - N1 --> N9; N1 --> N5; + N1 --> N7; + N1 --> N9; N2 --> N6; N3 --> N10; + N3 --> N5; + N3 --> N7; N3 --> N9; N4 --> N6; N4 --> N8; @@ -368,12 +390,14 @@ graph TD N6 --> N5; N7 --> N5; N7 --> N6; - N8 --> N7; N8 --> N5; - N9 --> N7; + N8 --> N7; N9 --> N5; + N9 --> N7; N9 --> N6; N9 --> N8; + N10 --> N5; + N10 --> N7; N10 --> N9; ``` # Entrypoints @@ -406,6 +430,12 @@ import { foobarCopy } from "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -423,12 +453,15 @@ export { upper } from "__TURBOPACK_VAR__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { foobar }; ``` @@ -445,6 +478,12 @@ export { foo }; import { internal } from "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -513,12 +552,12 @@ export { bar } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; let foobarCopy = foobar; export { foobarCopy } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true @@ -527,12 +566,12 @@ export { foobarCopy } from "__TURBOPACK_VAR__" assert { ``` ## Part 9 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; @@ -544,6 +583,12 @@ foobar += "foo"; ``` ## Part 10 ```js +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -567,6 +612,12 @@ import { foobarCopy } from "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -606,12 +657,12 @@ export { upper } from "__TURBOPACK_VAR__" assert { # Modules (prod) ## Part 0 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; "module evaluation"; import "module"; let foobarCopy = foobar; @@ -623,12 +674,15 @@ export { foobarCopy } from "__TURBOPACK_VAR__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; export { foobar }; ``` @@ -646,6 +700,12 @@ export { foo } from "__TURBOPACK_VAR__" assert { ``` ## Part 3 ```js +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; @@ -701,23 +761,23 @@ export { bar } from "__TURBOPACK_VAR__" assert { ``` ## Part 7 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; foobar += "foo"; ``` ## Merged (module eval) ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "module"; "module evaluation"; let foobarCopy = foobar; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/2/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/2/output.md index d121155292e1d..ab6b7dea87535 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/2/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/2/output.md @@ -217,24 +217,27 @@ graph TD Item8 --> Item7; Item8 --> Item5; Item8 -.-> Item6; - Item9 --> Item8; Item9 --> Item5; - Item10 --> Item8; + Item9 --> Item8; Item10 --> Item5; + Item10 --> Item8; Item10 -.-> Item6; Item10 -.-> Item9; Item11 --> Item9; Item11 --> Item1; Item11 --> Item2; Item11 -.-> Item13; + Item11 -.-> Item5; + Item11 -.-> Item8; Item11 -.-> Item10; Item11 -.-> Item6; Item11 -.-> Item4; Item12 --> Item9; Item12 -.-> Item11; Item16 --> Item3; - Item17 --> Item10; Item17 --> Item5; + Item17 --> Item8; + Item17 --> Item10; Item18 --> Item6; Item19 --> Item14; ``` @@ -270,29 +273,36 @@ graph TD Item8 --> Item7; Item8 --> Item5; Item8 -.-> Item6; - Item9 --> Item8; Item9 --> Item5; - Item10 --> Item8; + Item9 --> Item8; Item10 --> Item5; + Item10 --> Item8; Item10 -.-> Item6; Item10 -.-> Item9; Item11 --> Item9; Item11 --> Item1; Item11 --> Item2; Item11 -.-> Item13; + Item11 -.-> Item5; + Item11 -.-> Item8; Item11 -.-> Item10; Item11 -.-> Item6; Item11 -.-> Item4; Item12 --> Item9; Item12 -.-> Item11; Item16 --> Item3; - Item17 --> Item10; Item17 --> Item5; + Item17 --> Item8; + Item17 --> Item10; Item18 --> Item6; Item19 --> Item14; Item3 --> Item13; + Item3 --> Item5; + Item3 --> Item8; Item3 --> Item10; Item13 --> Item4; + Item13 --> Item5; + Item13 --> Item8; Item13 --> Item10; Item14 -.-> Item6; Item14 -.-> Item9; @@ -330,29 +340,36 @@ graph TD Item8 --> Item7; Item8 --> Item5; Item8 -.-> Item6; - Item9 --> Item8; Item9 --> Item5; - Item10 --> Item8; + Item9 --> Item8; Item10 --> Item5; + Item10 --> Item8; Item10 -.-> Item6; Item10 -.-> Item9; Item11 --> Item9; Item11 --> Item1; Item11 --> Item2; Item11 -.-> Item13; + Item11 -.-> Item5; + Item11 -.-> Item8; Item11 -.-> Item10; Item11 -.-> Item6; Item11 -.-> Item4; Item12 --> Item9; Item12 -.-> Item11; Item16 --> Item3; - Item17 --> Item10; Item17 --> Item5; + Item17 --> Item8; + Item17 --> Item10; Item18 --> Item6; Item19 --> Item14; Item3 --> Item13; + Item3 --> Item5; + Item3 --> Item8; Item3 --> Item10; Item13 --> Item4; + Item13 --> Item5; + Item13 --> Item8; Item13 --> Item10; Item14 -.-> Item6; Item14 -.-> Item9; @@ -377,12 +394,17 @@ graph TD N10["Items: [ItemId(1, ImportBinding(0)), ItemId(10, Normal)]"]; N0 --> N8; N0 --> N10; + N0 --> N5; + N0 --> N7; N0 --> N9; N0 --> N6; N1 --> N10; + N1 --> N5; + N1 --> N7; N1 --> N9; - N2 --> N9; N2 --> N5; + N2 --> N7; + N2 --> N9; N3 --> N6; N4 --> N6; N4 --> N8; @@ -390,12 +412,14 @@ graph TD N6 --> N5; N7 --> N5; N7 --> N6; - N8 --> N7; N8 --> N5; - N9 --> N7; + N8 --> N7; N9 --> N5; + N9 --> N7; N9 --> N6; N9 --> N8; + N10 --> N5; + N10 --> N7; N10 --> N9; ``` # Entrypoints @@ -428,6 +452,12 @@ import { foobarCopy } from "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -449,6 +479,12 @@ export { upper } from "__TURBOPACK_VAR__" assert { import { internal } from "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -463,12 +499,15 @@ export { external1 } from "__TURBOPACK_VAR__" assert { ``` ## Part 2 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { foobar }; ``` @@ -536,12 +575,12 @@ export { bar } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; let foobarCopy = foobar; export { foobarCopy } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true @@ -550,12 +589,12 @@ export { foobarCopy } from "__TURBOPACK_VAR__" assert { ``` ## Part 9 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; @@ -567,6 +606,12 @@ foobar += "foo"; ``` ## Part 10 ```js +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -590,6 +635,12 @@ import { foobarCopy } from "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -630,12 +681,12 @@ export { upper } from "__TURBOPACK_VAR__" assert { # Modules (prod) ## Part 0 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; "module evaluation"; import "module"; let foobarCopy = foobar; @@ -648,6 +699,12 @@ export { foobarCopy } from "__TURBOPACK_VAR__" assert { ``` ## Part 1 ```js +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; @@ -672,12 +729,15 @@ export { internal } from "__TURBOPACK_VAR__" assert { ``` ## Part 2 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; export { foobar }; ``` @@ -726,23 +786,23 @@ export { bar } from "__TURBOPACK_VAR__" assert { ``` ## Part 7 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; foobar += "foo"; ``` ## Merged (module eval) ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "module"; import "other"; "module evaluation"; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/complex/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/complex/output.md index 7929d55a7d44b..0a1c064b08e2b 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/complex/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/complex/output.md @@ -204,23 +204,29 @@ graph TD Item18; Item18["export getChimera"]; Item2 --> Item1; - Item3 --> Item2; Item3 --> Item1; - Item5 --> Item2; + Item3 --> Item2; Item5 --> Item1; + Item5 --> Item2; Item5 -.-> Item3; - Item6 --> Item5; Item6 --> Item1; + Item6 --> Item2; + Item6 --> Item5; Item6 --> Item3; - Item8 --> Item5; Item8 --> Item1; + Item8 --> Item2; + Item8 --> Item5; Item8 -.-> Item6; - Item9 --> Item8; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item5; + Item9 --> Item8; Item9 --> Item3; Item9 --> Item6; - Item10 --> Item8; Item10 --> Item1; + Item10 --> Item2; + Item10 --> Item5; + Item10 --> Item8; Item10 --> Item4; Item10 --> Item7; Item12 --> Item11; @@ -256,23 +262,29 @@ graph TD Item18; Item18["export getChimera"]; Item2 --> Item1; - Item3 --> Item2; Item3 --> Item1; - Item5 --> Item2; + Item3 --> Item2; Item5 --> Item1; + Item5 --> Item2; Item5 -.-> Item3; - Item6 --> Item5; Item6 --> Item1; + Item6 --> Item2; + Item6 --> Item5; Item6 --> Item3; - Item8 --> Item5; Item8 --> Item1; + Item8 --> Item2; + Item8 --> Item5; Item8 -.-> Item6; - Item9 --> Item8; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item5; + Item9 --> Item8; Item9 --> Item3; Item9 --> Item6; - Item10 --> Item8; Item10 --> Item1; + Item10 --> Item2; + Item10 --> Item5; + Item10 --> Item8; Item10 --> Item4; Item10 --> Item7; Item12 --> Item11; @@ -280,10 +292,16 @@ graph TD Item16 --> Item11; Item17 --> Item12; Item18 --> Item13; + Item4 --> Item1; + Item4 --> Item2; + Item4 --> Item5; Item4 --> Item8; Item7 -.-> Item9; Item7 -.-> Item10; Item13 --> Item11; + Item13 --> Item1; + Item13 --> Item2; + Item13 --> Item5; Item13 --> Item8; ``` # Phase 4 @@ -313,23 +331,29 @@ graph TD Item18; Item18["export getChimera"]; Item2 --> Item1; - Item3 --> Item2; Item3 --> Item1; - Item5 --> Item2; + Item3 --> Item2; Item5 --> Item1; + Item5 --> Item2; Item5 -.-> Item3; - Item6 --> Item5; Item6 --> Item1; + Item6 --> Item2; + Item6 --> Item5; Item6 --> Item3; - Item8 --> Item5; Item8 --> Item1; + Item8 --> Item2; + Item8 --> Item5; Item8 -.-> Item6; - Item9 --> Item8; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item5; + Item9 --> Item8; Item9 --> Item3; Item9 --> Item6; - Item10 --> Item8; Item10 --> Item1; + Item10 --> Item2; + Item10 --> Item5; + Item10 --> Item8; Item10 --> Item4; Item10 --> Item7; Item12 --> Item11; @@ -337,10 +361,16 @@ graph TD Item16 --> Item11; Item17 --> Item12; Item18 --> Item13; + Item4 --> Item1; + Item4 --> Item2; + Item4 --> Item5; Item4 --> Item8; Item7 -.-> Item9; Item7 -.-> Item10; Item13 --> Item11; + Item13 --> Item1; + Item13 --> Item2; + Item13 --> Item5; Item13 --> Item8; Item14 --> Item3; Item14 --> Item6; @@ -370,24 +400,33 @@ graph TD N2 --> N13; N3 --> N13; N4 --> N13; + N4 --> N6; + N4 --> N7; + N4 --> N9; N4 --> N11; + N5 --> N6; + N5 --> N7; + N5 --> N9; N5 --> N11; N5 --> N12; - N5 --> N6; N7 --> N6; - N8 --> N7; N8 --> N6; - N9 --> N7; + N8 --> N7; N9 --> N6; + N9 --> N7; N9 --> N8; - N10 --> N9; N10 --> N6; + N10 --> N7; + N10 --> N9; N10 --> N8; - N11 --> N9; N11 --> N6; + N11 --> N7; + N11 --> N9; N11 --> N10; - N12 --> N11; N12 --> N6; + N12 --> N7; + N12 --> N9; + N12 --> N11; N12 --> N8; N12 --> N10; ``` @@ -460,6 +499,15 @@ export { initialCat } from "__TURBOPACK_VAR__" assert { import { cat } from "__TURBOPACK_PART__" assert { __turbopack_part__: 13 }; +import { dog } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 11 }; @@ -474,15 +522,21 @@ export { getChimera } from "__TURBOPACK_VAR__" assert { ``` ## Part 5 ```js +import { dog } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 11 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 12 }; -import { dog } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; function getDog() { return dog; } @@ -523,23 +577,23 @@ dog += "!"; ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; console.log(dog); ``` ## Part 9 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; @@ -548,12 +602,15 @@ dog += "!"; ``` ## Part 10 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; @@ -562,12 +619,15 @@ console.log(dog); ``` ## Part 11 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; @@ -576,12 +636,18 @@ dog += "!"; ``` ## Part 12 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 11 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; @@ -637,12 +703,12 @@ import "__TURBOPACK_PART__" assert { # Modules (prod) ## Part 0 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; @@ -657,12 +723,18 @@ console.log(dog); ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; export { dogRef }; function getDog() { return dog; @@ -711,6 +783,15 @@ export { initialCat } from "__TURBOPACK_VAR__" assert { import { cat } from "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; +import { dog } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; @@ -741,23 +822,26 @@ dog += "!"; ``` ## Part 7 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; dog += "!"; ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; dog += "!"; ``` @@ -771,12 +855,12 @@ export { cat } from "__TURBOPACK_VAR__" assert { ``` ## Merged (module eval) ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { dog } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/failed-2/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/failed-2/output.md index 361e8588ef2c0..9610f4fbf9d44 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/failed-2/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/failed-2/output.md @@ -464,9 +464,11 @@ graph TD Item13 --> Item15; Item14 --> Item15; Item15 --> Item18; + Item15 --> Item5; Item15 --> Item9; Item18 --> Item9; Item19 --> Item18; + Item19 --> Item5; Item19 --> Item9; ``` # Phase 4 @@ -535,9 +537,11 @@ graph TD Item13 --> Item15; Item14 --> Item15; Item15 --> Item18; + Item15 --> Item5; Item15 --> Item9; Item18 --> Item9; Item19 --> Item18; + Item19 --> Item5; Item19 --> Item9; Item20 --> Item1; Item20 --> Item2; @@ -555,9 +559,9 @@ graph TD N5["Items: [ItemId(Export(("trackDynamicFetch", #2), "trackDynamicFetch")), ItemId(9, Normal)]"]; N6["Items: [ItemId(Export(("usedDynamicAPIs", #2), "usedDynamicAPIs")), ItemId(11, Normal)]"]; N7["Items: [ItemId(Export(("formatDynamicAPIAccesses", #2), "formatDynamicAPIAccesses")), ItemId(12, Normal)]"]; - N8["Items: [ItemId(Export(("createPostponedAbortSignal", #2), "createPostponedAbortSignal")), ItemId(14, Normal)]"]; + N8["Items: [ItemId(Export(("createPostponedAbortSignal", #2), "createPostponedAbortSignal")), ItemId(0, ImportBinding(0)), ItemId(14, Normal)]"]; N9["Items: [ItemId(0, ImportBinding(0)), ItemId(4, VarDeclarator(0))]"]; - N10["Items: [ItemId(10, Normal)]"]; + N10["Items: [ItemId(0, ImportBinding(0)), ItemId(10, Normal)]"]; N11["Items: [ItemId(13, Normal)]"]; N2 --> N3; N2 --> N10; @@ -565,7 +569,9 @@ graph TD N4 --> N10; N5 --> N10; N8 --> N11; + N8 --> N10; N8 --> N9; + N9 --> N10; N10 --> N11; N10 --> N9; N11 --> N9; @@ -782,10 +788,14 @@ export { formatDynamicAPIAccesses } from "__TURBOPACK_VAR__" assert { import { assertPostpone } from "__TURBOPACK_PART__" assert { __turbopack_part__: 11 }; -import { React } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; +import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; export { createPostponedAbortSignal }; +import React from 'react'; function createPostponedAbortSignal(reason) { assertPostpone(); const controller = new AbortController(); @@ -796,6 +806,9 @@ function createPostponedAbortSignal(reason) { } return controller.signal; } +export { React } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; export { createPostponedAbortSignal } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; @@ -803,6 +816,9 @@ export { createPostponedAbortSignal } from "__TURBOPACK_VAR__" assert { ``` ## Part 9 ```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; import React from 'react'; const hasPostpone = typeof React.unstable_postpone === 'function'; export { React } from "__TURBOPACK_VAR__" assert { @@ -818,9 +834,10 @@ export { hasPostpone } from "__TURBOPACK_VAR__" assert { import { assertPostpone } from "__TURBOPACK_PART__" assert { __turbopack_part__: 11 }; -import { React } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; +import React from 'react'; function postponeWithTracking(prerenderState, expression, pathname) { assertPostpone(); const reason = `Route ${pathname} needs to bail out of prerendering at this point because it used ${expression}. ` + `React throws this special object to indicate where. It should not be caught by ` + `your own try/catch. Learn more: https://nextjs.org/docs/messages/ppr-caught-error`; @@ -830,6 +847,9 @@ function postponeWithTracking(prerenderState, expression, pathname) { }); React.unstable_postpone(reason); } +export { React } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; export { postponeWithTracking } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; @@ -1071,10 +1091,14 @@ export { formatDynamicAPIAccesses } from "__TURBOPACK_VAR__" assert { import { assertPostpone } from "__TURBOPACK_PART__" assert { __turbopack_part__: 11 }; -import { React } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; +import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; export { createPostponedAbortSignal }; +import React from 'react'; function createPostponedAbortSignal(reason) { assertPostpone(); const controller = new AbortController(); @@ -1085,6 +1109,9 @@ function createPostponedAbortSignal(reason) { } return controller.signal; } +export { React } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; export { createPostponedAbortSignal } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; @@ -1092,6 +1119,9 @@ export { createPostponedAbortSignal } from "__TURBOPACK_VAR__" assert { ``` ## Part 9 ```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; import React from 'react'; const hasPostpone = typeof React.unstable_postpone === 'function'; export { React } from "__TURBOPACK_VAR__" assert { @@ -1107,9 +1137,10 @@ export { hasPostpone } from "__TURBOPACK_VAR__" assert { import { assertPostpone } from "__TURBOPACK_PART__" assert { __turbopack_part__: 11 }; -import { React } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; +import React from 'react'; function postponeWithTracking(prerenderState, expression, pathname) { assertPostpone(); const reason = `Route ${pathname} needs to bail out of prerendering at this point because it used ${expression}. ` + `React throws this special object to indicate where. It should not be caught by ` + `your own try/catch. Learn more: https://nextjs.org/docs/messages/ppr-caught-error`; @@ -1119,6 +1150,9 @@ function postponeWithTracking(prerenderState, expression, pathname) { }); React.unstable_postpone(reason); } +export { React } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; export { postponeWithTracking } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/grouping/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/grouping/output.md index 6426c3f4376c8..b3858c2e9183b 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/grouping/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/grouping/output.md @@ -162,19 +162,38 @@ graph TD Item7 --> Item3; Item7 --> Item6; Item7 -.-> Item4; - Item8 --> Item7; Item8 --> Item1; + Item8 --> Item3; + Item8 --> Item6; + Item8 --> Item7; Item8 -.-> Item4; - Item9 --> Item8; Item9 --> Item1; + Item9 --> Item3; + Item9 --> Item6; + Item9 --> Item7; + Item9 --> Item8; Item9 -.-> Item4; - Item10 --> Item9; Item10 --> Item1; + Item10 --> Item3; + Item10 --> Item6; + Item10 --> Item7; + Item10 --> Item8; + Item10 --> Item9; Item10 -.-> Item4; - Item11 --> Item10; Item11 --> Item1; - Item13 --> Item10; + Item11 --> Item3; + Item11 --> Item6; + Item11 --> Item7; + Item11 --> Item8; + Item11 --> Item9; + Item11 --> Item10; Item13 --> Item1; + Item13 --> Item3; + Item13 --> Item6; + Item13 --> Item7; + Item13 --> Item8; + Item13 --> Item9; + Item13 --> Item10; Item14 --> Item11; ``` # Phase 3 @@ -209,19 +228,38 @@ graph TD Item7 --> Item3; Item7 --> Item6; Item7 -.-> Item4; - Item8 --> Item7; Item8 --> Item1; + Item8 --> Item3; + Item8 --> Item6; + Item8 --> Item7; Item8 -.-> Item4; - Item9 --> Item8; Item9 --> Item1; + Item9 --> Item3; + Item9 --> Item6; + Item9 --> Item7; + Item9 --> Item8; Item9 -.-> Item4; - Item10 --> Item9; Item10 --> Item1; + Item10 --> Item3; + Item10 --> Item6; + Item10 --> Item7; + Item10 --> Item8; + Item10 --> Item9; Item10 -.-> Item4; - Item11 --> Item10; Item11 --> Item1; - Item13 --> Item10; + Item11 --> Item3; + Item11 --> Item6; + Item11 --> Item7; + Item11 --> Item8; + Item11 --> Item9; + Item11 --> Item10; Item13 --> Item1; + Item13 --> Item3; + Item13 --> Item6; + Item13 --> Item7; + Item13 --> Item8; + Item13 --> Item9; + Item13 --> Item10; Item14 --> Item11; ``` # Phase 4 @@ -256,19 +294,38 @@ graph TD Item7 --> Item3; Item7 --> Item6; Item7 -.-> Item4; - Item8 --> Item7; Item8 --> Item1; + Item8 --> Item3; + Item8 --> Item6; + Item8 --> Item7; Item8 -.-> Item4; - Item9 --> Item8; Item9 --> Item1; + Item9 --> Item3; + Item9 --> Item6; + Item9 --> Item7; + Item9 --> Item8; Item9 -.-> Item4; - Item10 --> Item9; Item10 --> Item1; + Item10 --> Item3; + Item10 --> Item6; + Item10 --> Item7; + Item10 --> Item8; + Item10 --> Item9; Item10 -.-> Item4; - Item11 --> Item10; Item11 --> Item1; - Item13 --> Item10; + Item11 --> Item3; + Item11 --> Item6; + Item11 --> Item7; + Item11 --> Item8; + Item11 --> Item9; + Item11 --> Item10; Item13 --> Item1; + Item13 --> Item3; + Item13 --> Item6; + Item13 --> Item7; + Item13 --> Item8; + Item13 --> Item9; + Item13 --> Item10; Item14 --> Item11; Item12 --> Item4; ``` @@ -281,18 +338,53 @@ graph TD N3["Items: [ItemId(0, VarDeclarator(0))]"]; N4["Items: [ItemId(2, Normal)]"]; N5["Items: [ItemId(3, Normal)]"]; - N6["Items: [ItemId(5, Normal), ItemId(6, Normal), ItemId(7, Normal), ItemId(8, Normal), ItemId(9, Normal)]"]; + N6["Items: [ItemId(5, Normal)]"]; + N7["Items: [ItemId(6, Normal)]"]; + N8["Items: [ItemId(7, Normal)]"]; + N9["Items: [ItemId(8, Normal)]"]; + N10["Items: [ItemId(9, Normal)]"]; N0 --> N5; - N1 --> N6; N1 --> N3; - N2 --> N6; + N1 --> N4; + N1 --> N6; + N1 --> N7; + N1 --> N8; + N1 --> N9; + N1 --> N10; N2 --> N3; + N2 --> N4; + N2 --> N6; + N2 --> N7; + N2 --> N8; + N2 --> N9; + N2 --> N10; N4 --> N3; N5 --> N3; N5 --> N4; N6 --> N5; N6 --> N3; - N6 --> N4; + N7 --> N3; + N7 --> N4; + N7 --> N6; + N7 --> N5; + N8 --> N3; + N8 --> N4; + N8 --> N6; + N8 --> N7; + N8 --> N5; + N9 --> N3; + N9 --> N4; + N9 --> N6; + N9 --> N7; + N9 --> N8; + N9 --> N5; + N10 --> N3; + N10 --> N4; + N10 --> N6; + N10 --> N7; + N10 --> N8; + N10 --> N9; + N10 --> N5; ``` # Entrypoints @@ -320,22 +412,52 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; -import { x } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 3 +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 }; export { x as x }; ``` ## Part 2 ```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; -import { x } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 3 +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 }; export { y }; const y = x; @@ -379,13 +501,92 @@ import "__TURBOPACK_PART__" assert { import { x } from "__TURBOPACK_PART__" assert { __turbopack_part__: 3 }; +x = 5; + +``` +## Part 7 +```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; -x = 5; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; x += 6; + +``` +## Part 8 +```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; x += 7; + +``` +## Part 9 +```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; x += 8; + +``` +## Part 10 +```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; x += 9; ``` @@ -427,22 +628,52 @@ console.log(x); ``` ## Part 1 ```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; -import { x } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 3 +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 }; export { x as x }; ``` ## Part 2 ```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; -import { x } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 3 +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 }; export { y }; const y = x; @@ -466,16 +697,80 @@ x = 3; ``` ## Part 5 ```js +x = 5; + +``` +## Part 6 +```js import { x } from "__TURBOPACK_PART__" assert { __turbopack_part__: 3 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; -x = 5; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; x += 6; + +``` +## Part 7 +```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; x += 7; + +``` +## Part 8 +```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; x += 8; + +``` +## Part 9 +```js +import { x } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; x += 9; ``` diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/route-kind/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/route-kind/output.md index b786b9b06e654..4ba4776c9eb85 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/route-kind/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/route-kind/output.md @@ -48,8 +48,8 @@ graph TD Item4; Item4["export RouteKind"]; Item2 --> Item1; - Item4 --> Item2; Item4 --> Item1; + Item4 --> Item2; ``` # Phase 3 ```mermaid @@ -61,8 +61,8 @@ graph TD Item4; Item4["export RouteKind"]; Item2 --> Item1; - Item4 --> Item2; Item4 --> Item1; + Item4 --> Item2; ``` # Phase 4 ```mermaid @@ -74,8 +74,8 @@ graph TD Item4; Item4["export RouteKind"]; Item2 --> Item1; - Item4 --> Item2; Item4 --> Item1; + Item4 --> Item2; Item3 --> Item2; ``` # Final @@ -86,8 +86,8 @@ graph TD N2["Items: [ItemId(0, VarDeclarator(0))]"]; N3["Items: [ItemId(1, Normal)]"]; N0 --> N3; - N1 --> N3; N1 --> N2; + N1 --> N3; N3 --> N2; ``` # Entrypoints @@ -113,12 +113,12 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 3 -}; import { RouteKind } from "__TURBOPACK_PART__" assert { __turbopack_part__: 2 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; export { RouteKind }; ``` @@ -174,12 +174,12 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 3 -}; import { RouteKind } from "__TURBOPACK_PART__" assert { __turbopack_part__: 2 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; export { RouteKind }; ``` diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/shared-2/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/shared-2/output.md index ac5007085d28d..006b715ad7af5 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/shared-2/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/shared-2/output.md @@ -127,16 +127,18 @@ graph TD Item2 --> Item1; Item3 --> Item2; Item4 --> Item3; - Item4 --> Item2; Item4 --> Item1; - Item5 --> Item4; + Item4 --> Item2; Item5 --> Item1; Item5 --> Item2; + Item5 --> Item4; Item5 --> Item3; Item6 --> Item4; Item7 --> Item4; - Item9 --> Item5; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item4; + Item9 --> Item5; Item10 --> Item6; Item11 --> Item7; ``` @@ -161,16 +163,18 @@ graph TD Item2 --> Item1; Item3 --> Item2; Item4 --> Item3; - Item4 --> Item2; Item4 --> Item1; - Item5 --> Item4; + Item4 --> Item2; Item5 --> Item1; Item5 --> Item2; + Item5 --> Item4; Item5 --> Item3; Item6 --> Item4; Item7 --> Item4; - Item9 --> Item5; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item4; + Item9 --> Item5; Item10 --> Item6; Item11 --> Item7; ``` @@ -195,16 +199,18 @@ graph TD Item2 --> Item1; Item3 --> Item2; Item4 --> Item3; - Item4 --> Item2; Item4 --> Item1; - Item5 --> Item4; + Item4 --> Item2; Item5 --> Item1; Item5 --> Item2; + Item5 --> Item4; Item5 --> Item3; Item6 --> Item4; Item7 --> Item4; - Item9 --> Item5; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item4; + Item9 --> Item5; Item10 --> Item6; Item11 --> Item7; Item8 --> Item2; @@ -226,18 +232,20 @@ graph TD N0 --> N5; N0 --> N6; N0 --> N8; - N1 --> N8; N1 --> N4; + N1 --> N5; + N1 --> N7; + N1 --> N8; N2 --> N7; N3 --> N7; N5 --> N4; N6 --> N5; N7 --> N6; - N7 --> N5; N7 --> N4; - N8 --> N7; + N7 --> N5; N8 --> N4; N8 --> N5; + N8 --> N7; N8 --> N6; ``` # Entrypoints @@ -275,12 +283,18 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; export { order }; ``` @@ -346,12 +360,12 @@ export { random } from "__TURBOPACK_VAR__" assert { import { random } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 5 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; const shared = { random, effect: order.push("b") @@ -363,15 +377,15 @@ export { shared } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; @@ -427,12 +441,18 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; export { order }; ``` @@ -498,12 +518,12 @@ export { random } from "__TURBOPACK_VAR__" assert { import { random } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 5 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; const shared = { random, effect: order.push("b") @@ -515,15 +535,15 @@ export { shared } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/shared-regression/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/shared-regression/output.md index ac5007085d28d..006b715ad7af5 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/shared-regression/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/shared-regression/output.md @@ -127,16 +127,18 @@ graph TD Item2 --> Item1; Item3 --> Item2; Item4 --> Item3; - Item4 --> Item2; Item4 --> Item1; - Item5 --> Item4; + Item4 --> Item2; Item5 --> Item1; Item5 --> Item2; + Item5 --> Item4; Item5 --> Item3; Item6 --> Item4; Item7 --> Item4; - Item9 --> Item5; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item4; + Item9 --> Item5; Item10 --> Item6; Item11 --> Item7; ``` @@ -161,16 +163,18 @@ graph TD Item2 --> Item1; Item3 --> Item2; Item4 --> Item3; - Item4 --> Item2; Item4 --> Item1; - Item5 --> Item4; + Item4 --> Item2; Item5 --> Item1; Item5 --> Item2; + Item5 --> Item4; Item5 --> Item3; Item6 --> Item4; Item7 --> Item4; - Item9 --> Item5; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item4; + Item9 --> Item5; Item10 --> Item6; Item11 --> Item7; ``` @@ -195,16 +199,18 @@ graph TD Item2 --> Item1; Item3 --> Item2; Item4 --> Item3; - Item4 --> Item2; Item4 --> Item1; - Item5 --> Item4; + Item4 --> Item2; Item5 --> Item1; Item5 --> Item2; + Item5 --> Item4; Item5 --> Item3; Item6 --> Item4; Item7 --> Item4; - Item9 --> Item5; Item9 --> Item1; + Item9 --> Item2; + Item9 --> Item4; + Item9 --> Item5; Item10 --> Item6; Item11 --> Item7; Item8 --> Item2; @@ -226,18 +232,20 @@ graph TD N0 --> N5; N0 --> N6; N0 --> N8; - N1 --> N8; N1 --> N4; + N1 --> N5; + N1 --> N7; + N1 --> N8; N2 --> N7; N3 --> N7; N5 --> N4; N6 --> N5; N7 --> N6; - N7 --> N5; N7 --> N4; - N8 --> N7; + N7 --> N5; N8 --> N4; N8 --> N5; + N8 --> N7; N8 --> N6; ``` # Entrypoints @@ -275,12 +283,18 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; export { order }; ``` @@ -346,12 +360,12 @@ export { random } from "__TURBOPACK_VAR__" assert { import { random } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 5 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; const shared = { random, effect: order.push("b") @@ -363,15 +377,15 @@ export { shared } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; @@ -427,12 +441,18 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; export { order }; ``` @@ -498,12 +518,12 @@ export { random } from "__TURBOPACK_VAR__" assert { import { random } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 5 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; const shared = { random, effect: order.push("b") @@ -515,15 +535,15 @@ export { shared } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/test-config-1/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/test-config-1/output.md index 867b54c937d69..9a5ae6c22a0d1 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/test-config-1/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/test-config-1/output.md @@ -203,22 +203,25 @@ graph TD Item6 --> Item5; Item6 --> Item3; Item6 -.-> Item4; - Item7 --> Item6; Item7 --> Item3; - Item8 --> Item6; + Item7 --> Item6; Item8 --> Item3; + Item8 --> Item6; Item8 -.-> Item4; Item8 -.-> Item7; Item9 --> Item7; Item9 --> Item1; Item9 -.-> Item2; + Item9 -.-> Item3; + Item9 -.-> Item6; Item9 -.-> Item8; Item9 -.-> Item4; Item9 -.-> Item11; Item10 --> Item7; Item10 -.-> Item9; - Item15 --> Item8; Item15 --> Item3; + Item15 --> Item6; + Item15 --> Item8; Item16 --> Item4; Item17 --> Item12; Item18 --> Item13; @@ -253,28 +256,35 @@ graph TD Item6 --> Item5; Item6 --> Item3; Item6 -.-> Item4; - Item7 --> Item6; Item7 --> Item3; - Item8 --> Item6; + Item7 --> Item6; Item8 --> Item3; + Item8 --> Item6; Item8 -.-> Item4; Item8 -.-> Item7; Item9 --> Item7; Item9 --> Item1; Item9 -.-> Item2; + Item9 -.-> Item3; + Item9 -.-> Item6; Item9 -.-> Item8; Item9 -.-> Item4; Item9 -.-> Item11; Item10 --> Item7; Item10 -.-> Item9; - Item15 --> Item8; Item15 --> Item3; + Item15 --> Item6; + Item15 --> Item8; Item16 --> Item4; Item17 --> Item12; Item18 --> Item13; Item11 --> Item2; + Item11 --> Item3; + Item11 --> Item6; Item11 --> Item8; Item12 --> Item11; + Item12 --> Item3; + Item12 --> Item6; Item12 --> Item8; Item13 -.-> Item4; Item13 -.-> Item7; @@ -310,28 +320,35 @@ graph TD Item6 --> Item5; Item6 --> Item3; Item6 -.-> Item4; - Item7 --> Item6; Item7 --> Item3; - Item8 --> Item6; + Item7 --> Item6; Item8 --> Item3; + Item8 --> Item6; Item8 -.-> Item4; Item8 -.-> Item7; Item9 --> Item7; Item9 --> Item1; Item9 -.-> Item2; + Item9 -.-> Item3; + Item9 -.-> Item6; Item9 -.-> Item8; Item9 -.-> Item4; Item9 -.-> Item11; Item10 --> Item7; Item10 -.-> Item9; - Item15 --> Item8; Item15 --> Item3; + Item15 --> Item6; + Item15 --> Item8; Item16 --> Item4; Item17 --> Item12; Item18 --> Item13; Item11 --> Item2; + Item11 --> Item3; + Item11 --> Item6; Item11 --> Item8; Item12 --> Item11; + Item12 --> Item3; + Item12 --> Item6; Item12 --> Item8; Item13 -.-> Item4; Item13 -.-> Item7; @@ -355,12 +372,17 @@ graph TD N10["Items: [ItemId(0, ImportBinding(0)), ItemId(9, Normal)]"]; N0 --> N8; N0 --> N10; + N0 --> N5; + N0 --> N7; N0 --> N9; N0 --> N6; - N1 --> N9; N1 --> N5; + N1 --> N7; + N1 --> N9; N2 --> N6; N3 --> N10; + N3 --> N5; + N3 --> N7; N3 --> N9; N4 --> N6; N4 --> N8; @@ -368,12 +390,14 @@ graph TD N6 --> N5; N7 --> N5; N7 --> N6; - N8 --> N7; N8 --> N5; - N9 --> N7; + N8 --> N7; N9 --> N5; + N9 --> N7; N9 --> N6; N9 --> N8; + N10 --> N5; + N10 --> N7; N10 --> N9; ``` # Entrypoints @@ -406,6 +430,12 @@ import { foobarCopy } from "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -423,12 +453,15 @@ export { upper } from "__TURBOPACK_VAR__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { foobar }; ``` @@ -445,6 +478,12 @@ export { foo }; import { internal } from "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -513,12 +552,12 @@ export { bar } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; let foobarCopy = foobar; export { foobarCopy } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true @@ -527,12 +566,12 @@ export { foobarCopy } from "__TURBOPACK_VAR__" assert { ``` ## Part 9 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; @@ -544,6 +583,12 @@ foobar += "foo"; ``` ## Part 10 ```js +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -567,6 +612,12 @@ import { foobarCopy } from "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 10 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -606,12 +657,12 @@ export { upper } from "__TURBOPACK_VAR__" assert { # Modules (prod) ## Part 0 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; "module evaluation"; import "module"; let foobarCopy = foobar; @@ -623,12 +674,15 @@ export { foobarCopy } from "__TURBOPACK_VAR__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; export { foobar }; ``` @@ -646,6 +700,12 @@ export { foo } from "__TURBOPACK_VAR__" assert { ``` ## Part 3 ```js +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; @@ -701,23 +761,23 @@ export { bar } from "__TURBOPACK_VAR__" assert { ``` ## Part 7 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; foobar += "foo"; ``` ## Merged (module eval) ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; import { foobar } from "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "module"; "module evaluation"; let foobarCopy = foobar; @@ -750,6 +810,12 @@ export { foobarCopy } from "__TURBOPACK_VAR__" assert { ## Merged (external1) ```js +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; @@ -795,6 +861,12 @@ export { external1 } from "__TURBOPACK_VAR__" assert { ## Merged (external1,external2) ```js +import { foobar } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/write-order/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/write-order/output.md index 052eb476d8e5f..9a0166c0288d1 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/write-order/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/write-order/output.md @@ -123,17 +123,21 @@ graph TD Item11["export shared"]; Item3 --> Item1; Item4 --> Item3; + Item4 -.-> Item1; Item5 --> Item3; Item5 --> Item4; - Item6 --> Item3; + Item5 -.-> Item1; Item6 --> Item1; - Item7 --> Item6; + Item6 --> Item3; Item7 --> Item1; Item7 --> Item3; + Item7 --> Item6; Item7 --> Item4; Item7 --> Item5; - Item9 --> Item7; Item9 --> Item1; + Item9 --> Item3; + Item9 --> Item6; + Item9 --> Item7; Item10 --> Item2; Item11 --> Item6; ``` @@ -157,19 +161,26 @@ graph TD Item11["export shared"]; Item3 --> Item1; Item4 --> Item3; + Item4 -.-> Item1; Item5 --> Item3; Item5 --> Item4; - Item6 --> Item3; + Item5 -.-> Item1; Item6 --> Item1; - Item7 --> Item6; + Item6 --> Item3; Item7 --> Item1; Item7 --> Item3; + Item7 --> Item6; Item7 --> Item4; Item7 --> Item5; - Item9 --> Item7; Item9 --> Item1; + Item9 --> Item3; + Item9 --> Item6; + Item9 --> Item7; Item10 --> Item2; Item11 --> Item6; + Item2 --> Item1; + Item2 --> Item3; + Item2 --> Item6; Item2 --> Item7; Item2 -.-> Item9; ``` @@ -193,19 +204,26 @@ graph TD Item11["export shared"]; Item3 --> Item1; Item4 --> Item3; + Item4 -.-> Item1; Item5 --> Item3; Item5 --> Item4; - Item6 --> Item3; + Item5 -.-> Item1; Item6 --> Item1; - Item7 --> Item6; + Item6 --> Item3; Item7 --> Item1; Item7 --> Item3; + Item7 --> Item6; Item7 --> Item4; Item7 --> Item5; - Item9 --> Item7; Item9 --> Item1; + Item9 --> Item3; + Item9 --> Item6; + Item9 --> Item7; Item10 --> Item2; Item11 --> Item6; + Item2 --> Item1; + Item2 --> Item3; + Item2 --> Item6; Item2 --> Item7; Item2 -.-> Item9; Item8 --> Item3; @@ -230,20 +248,27 @@ graph TD N0 --> N6; N0 --> N7; N0 --> N9; - N1 --> N9; N1 --> N4; + N1 --> N5; + N1 --> N8; + N1 --> N9; + N2 --> N4; + N2 --> N5; + N2 --> N8; N2 --> N9; N2 --> N1; N3 --> N8; N5 --> N4; N6 --> N5; + N6 --> N4; N7 --> N5; N7 --> N6; - N8 --> N5; + N7 --> N4; N8 --> N4; - N9 --> N8; + N8 --> N5; N9 --> N4; N9 --> N5; + N9 --> N8; N9 --> N6; N9 --> N7; ``` @@ -285,17 +310,32 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { order }; ``` ## Part 2 ```js +import { order } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -340,6 +380,9 @@ order.push("a"); import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; const x1 = externalFunction(); export { x1 } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true @@ -354,6 +397,9 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; const x2 = externalFunction(); export { x2 } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true @@ -362,12 +408,12 @@ export { x2 } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 5 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; const shared = { effect: order.push("b") }; @@ -378,15 +424,15 @@ export { shared } from "__TURBOPACK_VAR__" assert { ``` ## Part 9 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; @@ -451,17 +497,32 @@ import "__TURBOPACK_PART__" assert { ``` ## Part 1 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { order }; ``` ## Part 2 ```js +import { order } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; @@ -525,12 +586,12 @@ export { x2 } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 5 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; const shared = { effect: order.push("b") }; @@ -541,15 +602,15 @@ export { shared } from "__TURBOPACK_VAR__" assert { ``` ## Part 9 ```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; import { order } from "__TURBOPACK_PART__" assert { __turbopack_part__: 4 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; From da310e225139ff94249ddc81337c50e25463e0b4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 14:53:50 +0900 Subject: [PATCH 015/154] TODO --- crates/turbopack-ecmascript/src/tree_shake/mod.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/crates/turbopack-ecmascript/src/tree_shake/mod.rs b/crates/turbopack-ecmascript/src/tree_shake/mod.rs index 4ce013d8e2d19..00520d4d9e101 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/mod.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/mod.rs @@ -205,6 +205,10 @@ impl Analyzer<'_> { // Optimization: Remove each module item to which we // just created a strong dependency from LAST_WRITES + // TODO(kdy1): Re-enable this optimization + // I disabled this optimization because it causes some issues while enabling + // tree ahking in next.js + // // state // .last_writes // .retain(|last_write| !self.g.has_dep(item_id, From cc62fd28a6546b88c3bfc53d53ff209f3aae8aad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 18:40:27 +0900 Subject: [PATCH 016/154] Add a tedst --- .../tree-shaker/analyzer/nextjs-tracer/input.js | 12 ++++++++++++ 1 file changed, 12 insertions(+) create mode 100644 crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/input.js diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/input.js b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/input.js new file mode 100644 index 0000000000000..ff2047fc8962a --- /dev/null +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/input.js @@ -0,0 +1,12 @@ +import { LogSpanAllowList, NextVanillaSpanAllowlist } from './constants'; +let api; +if (process.env.NEXT_RUNTIME === 'edge') { + api = require('@opentelemetry/api'); +} else { + try { + api = require('@opentelemetry/api'); + } catch (err) { + api = require('next/dist/compiled/@opentelemetry/api'); + } +} +const { context, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = api; From 3d8a85acc4afd8244f624c97b2ad026a4a1bf1be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 18:54:06 +0900 Subject: [PATCH 017/154] Update test refs --- .../analyzer/nextjs-tracer/output.md | 228 ++++++++++++++++++ 1 file changed, 228 insertions(+) create mode 100644 crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md new file mode 100644 index 0000000000000..f6420c8c7dc52 --- /dev/null +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md @@ -0,0 +1,228 @@ +# Items + +Count: 7 + +## Item 1: Stmt 0, `ImportOfModule` + +```js +import { LogSpanAllowList, NextVanillaSpanAllowlist } from './constants'; + +``` + +- Hoisted +- Side effects + +## Item 2: Stmt 0, `ImportBinding(0)` + +```js +import { LogSpanAllowList, NextVanillaSpanAllowlist } from './constants'; + +``` + +- Hoisted +- Declares: `LogSpanAllowList` + +## Item 3: Stmt 0, `ImportBinding(1)` + +```js +import { LogSpanAllowList, NextVanillaSpanAllowlist } from './constants'; + +``` + +- Hoisted +- Declares: `NextVanillaSpanAllowlist` + +## Item 4: Stmt 1, `VarDeclarator(0)` + +```js +let api; + +``` + +- Declares: `api` +- Write: `api` + +## Item 5: Stmt 2, `Normal` + +```js +if (process.env.NEXT_RUNTIME === 'edge') { + api = require('@opentelemetry/api'); +} else { + try { + api = require('@opentelemetry/api'); + } catch (err) { + api = require('next/dist/compiled/@opentelemetry/api'); + } +} + +``` + +- Side effects +- Write: `api` + +## Item 6: Stmt 3, `VarDeclarator(0)` + +```js +const { context, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = api; + +``` + +- Declares: `context`, `propagation`, `trace`, `SpanStatusCode`, `SpanKind`, `ROOT_CONTEXT` +- Reads: `api` +- Write: `context`, `propagation`, `trace`, `SpanStatusCode`, `SpanKind`, `ROOT_CONTEXT` + +# Phase 1 +```mermaid +graph TD + Item1; + Item2; + Item3; + Item4; + Item5; + Item6; + Item7; + Item7["ModuleEvaluation"]; +``` +# Phase 2 +```mermaid +graph TD + Item1; + Item2; + Item3; + Item4; + Item5; + Item6; + Item7; + Item7["ModuleEvaluation"]; + Item5 -.-> Item4; + Item5 --> Item1; + Item6 --> Item4; + Item6 --> Item5; +``` +# Phase 3 +```mermaid +graph TD + Item1; + Item2; + Item3; + Item4; + Item5; + Item6; + Item7; + Item7["ModuleEvaluation"]; + Item5 -.-> Item4; + Item5 --> Item1; + Item6 --> Item4; + Item6 --> Item5; +``` +# Phase 4 +```mermaid +graph TD + Item1; + Item2; + Item3; + Item4; + Item5; + Item6; + Item7; + Item7["ModuleEvaluation"]; + Item5 -.-> Item4; + Item5 --> Item1; + Item6 --> Item4; + Item6 --> Item5; + Item7 --> Item1; + Item7 --> Item5; +``` +# Final +```mermaid +graph TD + N0["Items: [ItemId(ModuleEvaluation), ItemId(0, ImportOfModule), ItemId(1, VarDeclarator(0)), ItemId(2, Normal)]"]; +``` +# Entrypoints + +``` +{ + ModuleEvaluation: 0, +} +``` + + +# Modules (dev) +## Part 0 +```js +"module evaluation"; +import './constants'; +let api; +if (process.env.NEXT_RUNTIME === 'edge') { + api = require('@opentelemetry/api'); +} else { + try { + api = require('@opentelemetry/api'); + } catch (err) { + api = require('next/dist/compiled/@opentelemetry/api'); + } +} +export { api } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Merged (module eval) +```js +import './constants'; +"module evaluation"; +let api; +if (process.env.NEXT_RUNTIME === 'edge') { + api = require('@opentelemetry/api'); +} else { + try { + api = require('@opentelemetry/api'); + } catch (err) { + api = require('next/dist/compiled/@opentelemetry/api'); + } +} +export { api } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +# Entrypoints + +``` +{ + ModuleEvaluation: 0, +} +``` + + +# Modules (prod) +## Part 0 +```js +"module evaluation"; +import './constants'; +if (process.env.NEXT_RUNTIME === 'edge') { + api = require('@opentelemetry/api'); +} else { + try { + api = require('@opentelemetry/api'); + } catch (err) { + api = require('next/dist/compiled/@opentelemetry/api'); + } +} + +``` +## Merged (module eval) +```js +import './constants'; +"module evaluation"; +if (process.env.NEXT_RUNTIME === 'edge') { + api = require('@opentelemetry/api'); +} else { + try { + api = require('@opentelemetry/api'); + } catch (err) { + api = require('next/dist/compiled/@opentelemetry/api'); + } +} + +``` From 1f825a31b0a3834752475e454817bd3b031cbf51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 19 Jun 2024 18:59:13 +0900 Subject: [PATCH 018/154] Use real input for testing --- .../analyzer/nextjs-tracer/input.js | 202 +++ .../analyzer/nextjs-tracer/output.md | 1386 ++++++++++++++++- 2 files changed, 1557 insertions(+), 31 deletions(-) diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/input.js b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/input.js index ff2047fc8962a..3fafa47598599 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/input.js +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/input.js @@ -1,5 +1,12 @@ import { LogSpanAllowList, NextVanillaSpanAllowlist } from './constants'; let api; +// we want to allow users to use their own version of @opentelemetry/api if they +// want to, so we try to require it first, and if it fails we fall back to the +// version that is bundled with Next.js +// this is because @opentelemetry/api has to be synced with the version of +// @opentelemetry/tracing that is used, and we don't want to force users to use +// the version that is bundled with Next.js. +// the API is ~stable, so this should be fine if (process.env.NEXT_RUNTIME === 'edge') { api = require('@opentelemetry/api'); } else { @@ -10,3 +17,198 @@ if (process.env.NEXT_RUNTIME === 'edge') { } } const { context, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = api; +const isPromise = (p)=>{ + return p !== null && typeof p === 'object' && typeof p.then === 'function'; +}; +export class BubbledError extends Error { + constructor(bubble, result){ + super(); + this.bubble = bubble; + this.result = result; + } +} +export function isBubbledError(error) { + if (typeof error !== 'object' || error === null) return false; + return error instanceof BubbledError; +} +const closeSpanWithError = (span, error)=>{ + if (isBubbledError(error) && error.bubble) { + span.setAttribute('next.bubble', true); + } else { + if (error) { + span.recordException(error); + } + span.setStatus({ + code: SpanStatusCode.ERROR, + message: error == null ? void 0 : error.message + }); + } + span.end(); +}; +/** we use this map to propagate attributes from nested spans to the top span */ const rootSpanAttributesStore = new Map(); +const rootSpanIdKey = api.createContextKey('next.rootSpanId'); +let lastSpanId = 0; +const getSpanId = ()=>lastSpanId++; +const clientTraceDataSetter = { + set (carrier, key, value) { + carrier.push({ + key, + value + }); + } +}; +class NextTracerImpl { + /** + * Returns an instance to the trace with configured name. + * Since wrap / trace can be defined in any place prior to actual trace subscriber initialization, + * This should be lazily evaluated. + */ getTracerInstance() { + return trace.getTracer('next.js', '0.0.1'); + } + getContext() { + return context; + } + getTracePropagationData() { + const activeContext = context.active(); + const entries = []; + propagation.inject(activeContext, entries, clientTraceDataSetter); + return entries; + } + getActiveScopeSpan() { + return trace.getSpan(context == null ? void 0 : context.active()); + } + withPropagatedContext(carrier, fn, getter) { + const activeContext = context.active(); + if (trace.getSpanContext(activeContext)) { + // Active span is already set, too late to propagate. + return fn(); + } + const remoteContext = propagation.extract(activeContext, carrier, getter); + return context.with(remoteContext, fn); + } + trace(...args) { + var _trace_getSpanContext; + const [type, fnOrOptions, fnOrEmpty] = args; + // coerce options form overload + const { fn, options } = typeof fnOrOptions === 'function' ? { + fn: fnOrOptions, + options: {} + } : { + fn: fnOrEmpty, + options: { + ...fnOrOptions + } + }; + const spanName = options.spanName ?? type; + if (!NextVanillaSpanAllowlist.includes(type) && process.env.NEXT_OTEL_VERBOSE !== '1' || options.hideSpan) { + return fn(); + } + // Trying to get active scoped span to assign parent. If option specifies parent span manually, will try to use it. + let spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan()); + let isRootSpan = false; + if (!spanContext) { + spanContext = (context == null ? void 0 : context.active()) ?? ROOT_CONTEXT; + isRootSpan = true; + } else if ((_trace_getSpanContext = trace.getSpanContext(spanContext)) == null ? void 0 : _trace_getSpanContext.isRemote) { + isRootSpan = true; + } + const spanId = getSpanId(); + options.attributes = { + 'next.span_name': spanName, + 'next.span_type': type, + ...options.attributes + }; + return context.with(spanContext.setValue(rootSpanIdKey, spanId), ()=>this.getTracerInstance().startActiveSpan(spanName, options, (span)=>{ + const startTime = 'performance' in globalThis && 'measure' in performance ? globalThis.performance.now() : undefined; + const onCleanup = ()=>{ + rootSpanAttributesStore.delete(spanId); + if (startTime && process.env.NEXT_OTEL_PERFORMANCE_PREFIX && LogSpanAllowList.includes(type || '')) { + performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-${(type.split('.').pop() || '').replace(/[A-Z]/g, (match)=>'-' + match.toLowerCase())}`, { + start: startTime, + end: performance.now() + }); + } + }; + if (isRootSpan) { + rootSpanAttributesStore.set(spanId, new Map(Object.entries(options.attributes ?? {}))); + } + try { + if (fn.length > 1) { + return fn(span, (err)=>closeSpanWithError(span, err)); + } + const result = fn(span); + if (isPromise(result)) { + // If there's error make sure it throws + return result.then((res)=>{ + span.end(); + // Need to pass down the promise result, + // it could be react stream response with error { error, stream } + return res; + }).catch((err)=>{ + closeSpanWithError(span, err); + throw err; + }).finally(onCleanup); + } else { + span.end(); + onCleanup(); + } + return result; + } catch (err) { + closeSpanWithError(span, err); + onCleanup(); + throw err; + } + })); + } + wrap(...args) { + const tracer = this; + const [name, options, fn] = args.length === 3 ? args : [ + args[0], + {}, + args[1] + ]; + if (!NextVanillaSpanAllowlist.includes(name) && process.env.NEXT_OTEL_VERBOSE !== '1') { + return fn; + } + return function() { + let optionsObj = options; + if (typeof optionsObj === 'function' && typeof fn === 'function') { + optionsObj = optionsObj.apply(this, arguments); + } + const lastArgId = arguments.length - 1; + const cb = arguments[lastArgId]; + if (typeof cb === 'function') { + const scopeBoundCb = tracer.getContext().bind(context.active(), cb); + return tracer.trace(name, optionsObj, (_span, done)=>{ + arguments[lastArgId] = function(err) { + done == null ? void 0 : done(err); + return scopeBoundCb.apply(this, arguments); + }; + return fn.apply(this, arguments); + }); + } else { + return tracer.trace(name, optionsObj, ()=>fn.apply(this, arguments)); + } + }; + } + startSpan(...args) { + const [type, options] = args; + const spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan()); + return this.getTracerInstance().startSpan(type, options, spanContext); + } + getSpanContext(parentSpan) { + const spanContext = parentSpan ? trace.setSpan(context.active(), parentSpan) : undefined; + return spanContext; + } + getRootSpanAttributes() { + const spanId = context.active().getValue(rootSpanIdKey); + return rootSpanAttributesStore.get(spanId); + } +} +const getTracer = (()=>{ + const tracer = new NextTracerImpl(); + return ()=>tracer; +})(); +export { getTracer, SpanStatusCode, SpanKind }; + +//# sourceMappingURL=tracer.js.map diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md index f6420c8c7dc52..07071e286bc19 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md @@ -1,6 +1,6 @@ # Items -Count: 7 +Count: 23 ## Item 1: Stmt 0, `ImportOfModule` @@ -71,6 +71,299 @@ const { context, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = - Reads: `api` - Write: `context`, `propagation`, `trace`, `SpanStatusCode`, `SpanKind`, `ROOT_CONTEXT` +## Item 7: Stmt 4, `VarDeclarator(0)` + +```js +const isPromise = (p)=>{ + return p !== null && typeof p === 'object' && typeof p.then === 'function'; +}; + +``` + +- Declares: `isPromise` +- Write: `isPromise` + +## Item 8: Stmt 5, `Normal` + +```js +export class BubbledError extends Error { + constructor(bubble, result){ + super(); + this.bubble = bubble; + this.result = result; + } +} + +``` + +- Hoisted +- Declares: `BubbledError` +- Write: `BubbledError` + +## Item 9: Stmt 6, `Normal` + +```js +export function isBubbledError(error) { + if (typeof error !== 'object' || error === null) return false; + return error instanceof BubbledError; +} + +``` + +- Hoisted +- Declares: `isBubbledError` +- Reads (eventual): `BubbledError` +- Write: `isBubbledError` + +## Item 10: Stmt 7, `VarDeclarator(0)` + +```js +const closeSpanWithError = (span, error)=>{ + if (isBubbledError(error) && error.bubble) { + span.setAttribute('next.bubble', true); + } else { + if (error) { + span.recordException(error); + } + span.setStatus({ + code: SpanStatusCode.ERROR, + message: error == null ? void 0 : error.message + }); + } + span.end(); +}; + +``` + +- Declares: `closeSpanWithError` +- Reads (eventual): `isBubbledError`, `SpanStatusCode` +- Write: `closeSpanWithError` +- Write (eventual): `SpanStatusCode` + +## Item 11: Stmt 8, `VarDeclarator(0)` + +```js +const rootSpanAttributesStore = new Map(); + +``` + +- Side effects +- Declares: `rootSpanAttributesStore` +- Write: `rootSpanAttributesStore` + +## Item 12: Stmt 9, `VarDeclarator(0)` + +```js +const rootSpanIdKey = api.createContextKey('next.rootSpanId'); + +``` + +- Declares: `rootSpanIdKey` +- Reads: `api` +- Write: `rootSpanIdKey`, `api` + +## Item 13: Stmt 10, `VarDeclarator(0)` + +```js +let lastSpanId = 0; + +``` + +- Declares: `lastSpanId` +- Write: `lastSpanId` + +## Item 14: Stmt 11, `VarDeclarator(0)` + +```js +const getSpanId = ()=>lastSpanId++; + +``` + +- Declares: `getSpanId` +- Reads (eventual): `lastSpanId` +- Write: `getSpanId` + +## Item 15: Stmt 12, `VarDeclarator(0)` + +```js +const clientTraceDataSetter = { + set (carrier, key, value) { + carrier.push({ + key, + value + }); + } +}; + +``` + +- Declares: `clientTraceDataSetter` +- Write: `clientTraceDataSetter` + +## Item 16: Stmt 13, `Normal` + +```js +class NextTracerImpl { + getTracerInstance() { + return trace.getTracer('next.js', '0.0.1'); + } + getContext() { + return context; + } + getTracePropagationData() { + const activeContext = context.active(); + const entries = []; + propagation.inject(activeContext, entries, clientTraceDataSetter); + return entries; + } + getActiveScopeSpan() { + return trace.getSpan(context == null ? void 0 : context.active()); + } + withPropagatedContext(carrier, fn, getter) { + const activeContext = context.active(); + if (trace.getSpanContext(activeContext)) { + return fn(); + } + const remoteContext = propagation.extract(activeContext, carrier, getter); + return context.with(remoteContext, fn); + } + trace(...args) { + var _trace_getSpanContext; + const [type, fnOrOptions, fnOrEmpty] = args; + const { fn, options } = typeof fnOrOptions === 'function' ? { + fn: fnOrOptions, + options: {} + } : { + fn: fnOrEmpty, + options: { + ...fnOrOptions + } + }; + const spanName = options.spanName ?? type; + if (!NextVanillaSpanAllowlist.includes(type) && process.env.NEXT_OTEL_VERBOSE !== '1' || options.hideSpan) { + return fn(); + } + let spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan()); + let isRootSpan = false; + if (!spanContext) { + spanContext = (context == null ? void 0 : context.active()) ?? ROOT_CONTEXT; + isRootSpan = true; + } else if ((_trace_getSpanContext = trace.getSpanContext(spanContext)) == null ? void 0 : _trace_getSpanContext.isRemote) { + isRootSpan = true; + } + const spanId = getSpanId(); + options.attributes = { + 'next.span_name': spanName, + 'next.span_type': type, + ...options.attributes + }; + return context.with(spanContext.setValue(rootSpanIdKey, spanId), ()=>this.getTracerInstance().startActiveSpan(spanName, options, (span)=>{ + const startTime = 'performance' in globalThis && 'measure' in performance ? globalThis.performance.now() : undefined; + const onCleanup = ()=>{ + rootSpanAttributesStore.delete(spanId); + if (startTime && process.env.NEXT_OTEL_PERFORMANCE_PREFIX && LogSpanAllowList.includes(type || '')) { + performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-${(type.split('.').pop() || '').replace(/[A-Z]/g, (match)=>'-' + match.toLowerCase())}`, { + start: startTime, + end: performance.now() + }); + } + }; + if (isRootSpan) { + rootSpanAttributesStore.set(spanId, new Map(Object.entries(options.attributes ?? {}))); + } + try { + if (fn.length > 1) { + return fn(span, (err)=>closeSpanWithError(span, err)); + } + const result = fn(span); + if (isPromise(result)) { + return result.then((res)=>{ + span.end(); + return res; + }).catch((err)=>{ + closeSpanWithError(span, err); + throw err; + }).finally(onCleanup); + } else { + span.end(); + onCleanup(); + } + return result; + } catch (err) { + closeSpanWithError(span, err); + onCleanup(); + throw err; + } + })); + } + wrap(...args) { + const tracer = this; + const [name, options, fn] = args.length === 3 ? args : [ + args[0], + {}, + args[1] + ]; + if (!NextVanillaSpanAllowlist.includes(name) && process.env.NEXT_OTEL_VERBOSE !== '1') { + return fn; + } + return function() { + let optionsObj = options; + if (typeof optionsObj === 'function' && typeof fn === 'function') { + optionsObj = optionsObj.apply(this, arguments); + } + const lastArgId = arguments.length - 1; + const cb = arguments[lastArgId]; + if (typeof cb === 'function') { + const scopeBoundCb = tracer.getContext().bind(context.active(), cb); + return tracer.trace(name, optionsObj, (_span, done)=>{ + arguments[lastArgId] = function(err) { + done == null ? void 0 : done(err); + return scopeBoundCb.apply(this, arguments); + }; + return fn.apply(this, arguments); + }); + } else { + return tracer.trace(name, optionsObj, ()=>fn.apply(this, arguments)); + } + }; + } + startSpan(...args) { + const [type, options] = args; + const spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan()); + return this.getTracerInstance().startSpan(type, options, spanContext); + } + getSpanContext(parentSpan) { + const spanContext = parentSpan ? trace.setSpan(context.active(), parentSpan) : undefined; + return spanContext; + } + getRootSpanAttributes() { + const spanId = context.active().getValue(rootSpanIdKey); + return rootSpanAttributesStore.get(spanId); + } +} + +``` + +- Hoisted +- Declares: `NextTracerImpl` +- Reads (eventual): `trace`, `context`, `propagation`, `clientTraceDataSetter`, `NextVanillaSpanAllowlist`, `ROOT_CONTEXT`, `getSpanId`, `rootSpanIdKey`, `rootSpanAttributesStore`, `LogSpanAllowList`, `closeSpanWithError`, `isPromise` +- Write: `NextTracerImpl` +- Write (eventual): `trace`, `context`, `propagation`, `NextVanillaSpanAllowlist`, `rootSpanAttributesStore`, `LogSpanAllowList` + +## Item 17: Stmt 14, `VarDeclarator(0)` + +```js +const getTracer = (()=>{ + const tracer = new NextTracerImpl(); + return ()=>tracer; +})(); + +``` + +- Declares: `getTracer` +- Reads (eventual): `NextTracerImpl` +- Write: `getTracer` + # Phase 1 ```mermaid graph TD @@ -81,7 +374,28 @@ graph TD Item5; Item6; Item7; - Item7["ModuleEvaluation"]; + Item8; + Item9; + Item10; + Item11; + Item12; + Item13; + Item14; + Item15; + Item16; + Item17; + Item18; + Item18["ModuleEvaluation"]; + Item19; + Item19["export BubbledError"]; + Item20; + Item20["export isBubbledError"]; + Item21; + Item21["export getTracer"]; + Item22; + Item22["export SpanStatusCode"]; + Item23; + Item23["export SpanKind"]; ``` # Phase 2 ```mermaid @@ -93,11 +407,55 @@ graph TD Item5; Item6; Item7; - Item7["ModuleEvaluation"]; + Item8; + Item9; + Item10; + Item11; + Item12; + Item13; + Item14; + Item15; + Item16; + Item17; + Item18; + Item18["ModuleEvaluation"]; + Item19; + Item19["export BubbledError"]; + Item20; + Item20["export isBubbledError"]; + Item21; + Item21["export getTracer"]; + Item22; + Item22["export SpanStatusCode"]; + Item23; + Item23["export SpanKind"]; Item5 -.-> Item4; Item5 --> Item1; + Item5 -.-> Item8; + Item5 -.-> Item9; + Item5 -.-> Item3; + Item5 -.-> Item2; + Item5 -.-> Item16; Item6 --> Item4; Item6 --> Item5; + Item11 --> Item1; + Item11 --> Item5; + Item11 -.-> Item8; + Item11 -.-> Item9; + Item11 -.-> Item6; + Item11 -.-> Item3; + Item11 -.-> Item2; + Item11 -.-> Item10; + Item11 -.-> Item7; + Item11 -.-> Item16; + Item12 --> Item4; + Item12 --> Item5; + Item12 -.-> Item6; + Item19 --> Item8; + Item20 --> Item9; + Item21 --> Item17; + Item22 --> Item6; + Item23 --> Item6; ``` # Phase 3 ```mermaid @@ -109,11 +467,70 @@ graph TD Item5; Item6; Item7; - Item7["ModuleEvaluation"]; + Item8; + Item9; + Item10; + Item11; + Item12; + Item13; + Item14; + Item15; + Item16; + Item17; + Item18; + Item18["ModuleEvaluation"]; + Item19; + Item19["export BubbledError"]; + Item20; + Item20["export isBubbledError"]; + Item21; + Item21["export getTracer"]; + Item22; + Item22["export SpanStatusCode"]; + Item23; + Item23["export SpanKind"]; Item5 -.-> Item4; Item5 --> Item1; + Item5 -.-> Item8; + Item5 -.-> Item9; + Item5 -.-> Item3; + Item5 -.-> Item2; + Item5 -.-> Item16; Item6 --> Item4; Item6 --> Item5; + Item11 --> Item1; + Item11 --> Item5; + Item11 -.-> Item8; + Item11 -.-> Item9; + Item11 -.-> Item6; + Item11 -.-> Item3; + Item11 -.-> Item2; + Item11 -.-> Item10; + Item11 -.-> Item7; + Item11 -.-> Item16; + Item12 --> Item4; + Item12 --> Item5; + Item12 -.-> Item6; + Item19 --> Item8; + Item20 --> Item9; + Item21 --> Item17; + Item22 --> Item6; + Item23 --> Item6; + Item9 --> Item8; + Item10 --> Item9; + Item10 --> Item6; + Item10 -.-> Item22; + Item14 --> Item13; + Item16 --> Item6; + Item16 --> Item15; + Item16 --> Item3; + Item16 --> Item14; + Item16 --> Item12; + Item16 --> Item11; + Item16 --> Item2; + Item16 --> Item10; + Item16 --> Item7; + Item17 --> Item16; ``` # Phase 4 ```mermaid @@ -125,24 +542,147 @@ graph TD Item5; Item6; Item7; - Item7["ModuleEvaluation"]; + Item8; + Item9; + Item10; + Item11; + Item12; + Item13; + Item14; + Item15; + Item16; + Item17; + Item18; + Item18["ModuleEvaluation"]; + Item19; + Item19["export BubbledError"]; + Item20; + Item20["export isBubbledError"]; + Item21; + Item21["export getTracer"]; + Item22; + Item22["export SpanStatusCode"]; + Item23; + Item23["export SpanKind"]; Item5 -.-> Item4; Item5 --> Item1; + Item5 -.-> Item8; + Item5 -.-> Item9; + Item5 -.-> Item3; + Item5 -.-> Item2; + Item5 -.-> Item16; Item6 --> Item4; Item6 --> Item5; - Item7 --> Item1; - Item7 --> Item5; + Item11 --> Item1; + Item11 --> Item5; + Item11 -.-> Item8; + Item11 -.-> Item9; + Item11 -.-> Item6; + Item11 -.-> Item3; + Item11 -.-> Item2; + Item11 -.-> Item10; + Item11 -.-> Item7; + Item11 -.-> Item16; + Item12 --> Item4; + Item12 --> Item5; + Item12 -.-> Item6; + Item19 --> Item8; + Item20 --> Item9; + Item21 --> Item17; + Item22 --> Item6; + Item23 --> Item6; + Item9 --> Item8; + Item10 --> Item9; + Item10 --> Item6; + Item10 -.-> Item22; + Item14 --> Item13; + Item16 --> Item6; + Item16 --> Item15; + Item16 --> Item3; + Item16 --> Item14; + Item16 --> Item12; + Item16 --> Item11; + Item16 --> Item2; + Item16 --> Item10; + Item16 --> Item7; + Item17 --> Item16; + Item18 --> Item1; + Item18 --> Item5; + Item18 --> Item11; ``` # Final ```mermaid graph TD - N0["Items: [ItemId(ModuleEvaluation), ItemId(0, ImportOfModule), ItemId(1, VarDeclarator(0)), ItemId(2, Normal)]"]; + N0["Items: [ItemId(ModuleEvaluation)]"]; + N1["Items: [ItemId(Export(("BubbledError", #2), "BubbledError"))]"]; + N2["Items: [ItemId(Export(("isBubbledError", #2), "isBubbledError"))]"]; + N3["Items: [ItemId(Export(("getTracer", #2), "getTracer")), ItemId(14, VarDeclarator(0))]"]; + N4["Items: [ItemId(Export(("SpanStatusCode", #2), "SpanStatusCode"))]"]; + N5["Items: [ItemId(Export(("SpanKind", #2), "SpanKind"))]"]; + N6["Items: [ItemId(0, ImportOfModule)]"]; + N7["Items: [ItemId(1, VarDeclarator(0))]"]; + N8["Items: [ItemId(0, ImportBinding(0)), ItemId(0, ImportBinding(1)), ItemId(2, Normal)]"]; + N9["Items: [ItemId(3, VarDeclarator(0))]"]; + N10["Items: [ItemId(4, VarDeclarator(0))]"]; + N11["Items: [ItemId(5, Normal)]"]; + N12["Items: [ItemId(6, Normal)]"]; + N13["Items: [ItemId(7, VarDeclarator(0))]"]; + N14["Items: [ItemId(0, ImportBinding(0)), ItemId(0, ImportBinding(1)), ItemId(8, VarDeclarator(0))]"]; + N15["Items: [ItemId(0, ImportBinding(0)), ItemId(0, ImportBinding(1)), ItemId(9, VarDeclarator(0)), ItemId(10, VarDeclarator(0)), ItemId(11, VarDeclarator(0)), ItemId(12, VarDeclarator(0)), ItemId(13, Normal)]"]; + N0 --> N6; + N0 --> N8; + N0 --> N14; + N1 --> N11; + N2 --> N12; + N3 --> N15; + N4 --> N9; + N5 --> N9; + N8 --> N7; + N8 --> N6; + N8 --> N11; + N8 --> N12; + N8 --> N15; + N9 --> N7; + N9 --> N8; + N12 --> N11; + N13 --> N12; + N13 --> N9; + N13 --> N4; + N14 --> N6; + N14 --> N8; + N14 --> N11; + N14 --> N12; + N14 --> N9; + N14 --> N15; + N14 --> N13; + N14 --> N10; + N15 --> N7; + N15 --> N8; + N15 --> N9; + N15 --> N14; + N15 --> N13; + N15 --> N10; ``` # Entrypoints ``` { ModuleEvaluation: 0, + Export( + "isBubbledError", + ): 2, + Export( + "SpanKind", + ): 5, + Export( + "SpanStatusCode", + ): 4, + Export( + "BubbledError", + ): 1, + Export( + "getTracer", + ): 3, } ``` @@ -150,9 +690,97 @@ graph TD # Modules (dev) ## Part 0 ```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 14 +}; "module evaluation"; + +``` +## Part 1 +```js +import { BubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; +export { BubbledError }; + +``` +## Part 2 +```js +import { isBubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 12 +}; +export { isBubbledError }; + +``` +## Part 3 +```js +import { NextTracerImpl } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 15 +}; +export { getTracer as getTracer }; +const getTracer = (()=>{ + const tracer = new NextTracerImpl(); + return ()=>tracer; +})(); +export { getTracer } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 4 +```js +import { SpanStatusCode } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +export { SpanStatusCode as SpanStatusCode }; + +``` +## Part 5 +```js +import { SpanKind } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +export { SpanKind as SpanKind }; + +``` +## Part 6 +```js import './constants'; + +``` +## Part 7 +```js let api; +export { api } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 8 +```js +import { api } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 12 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 15 +}; +import { LogSpanAllowList } from './constants'; +import { NextVanillaSpanAllowlist } from './constants'; if (process.env.NEXT_RUNTIME === 'edge') { api = require('@opentelemetry/api'); } else { @@ -162,35 +790,379 @@ if (process.env.NEXT_RUNTIME === 'edge') { api = require('next/dist/compiled/@opentelemetry/api'); } } -export { api } from "__TURBOPACK_VAR__" assert { +export { LogSpanAllowList } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { NextVanillaSpanAllowlist } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; ``` -## Merged (module eval) +## Part 9 ```js -import './constants'; -"module evaluation"; -let api; -if (process.env.NEXT_RUNTIME === 'edge') { - api = require('@opentelemetry/api'); -} else { - try { - api = require('@opentelemetry/api'); - } catch (err) { - api = require('next/dist/compiled/@opentelemetry/api'); +import { api } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +const { context, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = api; +export { context } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { propagation } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { trace } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { SpanStatusCode } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { SpanKind } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { ROOT_CONTEXT } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 10 +```js +const isPromise = (p)=>{ + return p !== null && typeof p === 'object' && typeof p.then === 'function'; +}; +export { isPromise } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 11 +```js +class BubbledError extends Error { + constructor(bubble, result){ + super(); + this.bubble = bubble; + this.result = result; } } -export { api } from "__TURBOPACK_VAR__" assert { +export { BubbledError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 12 +```js +import { BubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; +function isBubbledError(error) { + if (typeof error !== 'object' || error === null) return false; + return error instanceof BubbledError; +} +export { isBubbledError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 13 +```js +import { isBubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 12 +}; +import { SpanStatusCode } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +const closeSpanWithError = (span, error)=>{ + if (isBubbledError(error) && error.bubble) { + span.setAttribute('next.bubble', true); + } else { + if (error) { + span.recordException(error); + } + span.setStatus({ + code: SpanStatusCode.ERROR, + message: error == null ? void 0 : error.message + }); + } + span.end(); +}; +export { closeSpanWithError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 14 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 12 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 15 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 13 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; +import { LogSpanAllowList } from './constants'; +import { NextVanillaSpanAllowlist } from './constants'; +const rootSpanAttributesStore = new Map(); +export { LogSpanAllowList } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { NextVanillaSpanAllowlist } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { rootSpanAttributesStore } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; +``` +## Part 15 +```js +import { api } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import { context, propagation, trace, ROOT_CONTEXT } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import { rootSpanAttributesStore } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 14 +}; +import { closeSpanWithError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 13 +}; +import { isPromise } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; +import { LogSpanAllowList } from './constants'; +import { NextVanillaSpanAllowlist } from './constants'; +const rootSpanIdKey = api.createContextKey('next.rootSpanId'); +let lastSpanId = 0; +const getSpanId = ()=>lastSpanId++; +const clientTraceDataSetter = { + set (carrier, key, value) { + carrier.push({ + key, + value + }); + } +}; +class NextTracerImpl { + getTracerInstance() { + return trace.getTracer('next.js', '0.0.1'); + } + getContext() { + return context; + } + getTracePropagationData() { + const activeContext = context.active(); + const entries = []; + propagation.inject(activeContext, entries, clientTraceDataSetter); + return entries; + } + getActiveScopeSpan() { + return trace.getSpan(context == null ? void 0 : context.active()); + } + withPropagatedContext(carrier, fn, getter) { + const activeContext = context.active(); + if (trace.getSpanContext(activeContext)) { + return fn(); + } + const remoteContext = propagation.extract(activeContext, carrier, getter); + return context.with(remoteContext, fn); + } + trace(...args) { + var _trace_getSpanContext; + const [type, fnOrOptions, fnOrEmpty] = args; + const { fn, options } = typeof fnOrOptions === 'function' ? { + fn: fnOrOptions, + options: {} + } : { + fn: fnOrEmpty, + options: { + ...fnOrOptions + } + }; + const spanName = options.spanName ?? type; + if (!NextVanillaSpanAllowlist.includes(type) && process.env.NEXT_OTEL_VERBOSE !== '1' || options.hideSpan) { + return fn(); + } + let spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan()); + let isRootSpan = false; + if (!spanContext) { + spanContext = (context == null ? void 0 : context.active()) ?? ROOT_CONTEXT; + isRootSpan = true; + } else if ((_trace_getSpanContext = trace.getSpanContext(spanContext)) == null ? void 0 : _trace_getSpanContext.isRemote) { + isRootSpan = true; + } + const spanId = getSpanId(); + options.attributes = { + 'next.span_name': spanName, + 'next.span_type': type, + ...options.attributes + }; + return context.with(spanContext.setValue(rootSpanIdKey, spanId), ()=>this.getTracerInstance().startActiveSpan(spanName, options, (span)=>{ + const startTime = 'performance' in globalThis && 'measure' in performance ? globalThis.performance.now() : undefined; + const onCleanup = ()=>{ + rootSpanAttributesStore.delete(spanId); + if (startTime && process.env.NEXT_OTEL_PERFORMANCE_PREFIX && LogSpanAllowList.includes(type || '')) { + performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-${(type.split('.').pop() || '').replace(/[A-Z]/g, (match)=>'-' + match.toLowerCase())}`, { + start: startTime, + end: performance.now() + }); + } + }; + if (isRootSpan) { + rootSpanAttributesStore.set(spanId, new Map(Object.entries(options.attributes ?? {}))); + } + try { + if (fn.length > 1) { + return fn(span, (err)=>closeSpanWithError(span, err)); + } + const result = fn(span); + if (isPromise(result)) { + return result.then((res)=>{ + span.end(); + return res; + }).catch((err)=>{ + closeSpanWithError(span, err); + throw err; + }).finally(onCleanup); + } else { + span.end(); + onCleanup(); + } + return result; + } catch (err) { + closeSpanWithError(span, err); + onCleanup(); + throw err; + } + })); + } + wrap(...args) { + const tracer = this; + const [name, options, fn] = args.length === 3 ? args : [ + args[0], + {}, + args[1] + ]; + if (!NextVanillaSpanAllowlist.includes(name) && process.env.NEXT_OTEL_VERBOSE !== '1') { + return fn; + } + return function() { + let optionsObj = options; + if (typeof optionsObj === 'function' && typeof fn === 'function') { + optionsObj = optionsObj.apply(this, arguments); + } + const lastArgId = arguments.length - 1; + const cb = arguments[lastArgId]; + if (typeof cb === 'function') { + const scopeBoundCb = tracer.getContext().bind(context.active(), cb); + return tracer.trace(name, optionsObj, (_span, done)=>{ + arguments[lastArgId] = function(err) { + done == null ? void 0 : done(err); + return scopeBoundCb.apply(this, arguments); + }; + return fn.apply(this, arguments); + }); + } else { + return tracer.trace(name, optionsObj, ()=>fn.apply(this, arguments)); + } + }; + } + startSpan(...args) { + const [type, options] = args; + const spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan()); + return this.getTracerInstance().startSpan(type, options, spanContext); + } + getSpanContext(parentSpan) { + const spanContext = parentSpan ? trace.setSpan(context.active(), parentSpan) : undefined; + return spanContext; + } + getRootSpanAttributes() { + const spanId = context.active().getValue(rootSpanIdKey); + return rootSpanAttributesStore.get(spanId); + } +} +export { LogSpanAllowList } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { NextVanillaSpanAllowlist } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { rootSpanIdKey } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { lastSpanId } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { getSpanId } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { clientTraceDataSetter } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { NextTracerImpl } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Merged (module eval) +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 14 +}; +"module evaluation"; + ``` # Entrypoints ``` { ModuleEvaluation: 0, + Export( + "isBubbledError", + ): 2, + Export( + "SpanKind", + ): 5, + Export( + "SpanStatusCode", + ): 4, + Export( + "BubbledError", + ): 1, + Export( + "getTracer", + ): 3, } ``` @@ -198,23 +1170,290 @@ export { api } from "__TURBOPACK_VAR__" assert { # Modules (prod) ## Part 0 ```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 12 +}; "module evaluation"; -import './constants'; -if (process.env.NEXT_RUNTIME === 'edge') { - api = require('@opentelemetry/api'); -} else { - try { - api = require('@opentelemetry/api'); - } catch (err) { - api = require('next/dist/compiled/@opentelemetry/api'); + +``` +## Part 1 +```js +import { BubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; +export { BubbledError }; + +``` +## Part 2 +```js +import { isBubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; +export { isBubbledError }; + +``` +## Part 3 +```js +import { isBubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; +import { context, propagation, trace, SpanStatusCode, ROOT_CONTEXT } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import { api } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import { rootSpanAttributesStore } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 12 +}; +export { getTracer as getTracer }; +import { LogSpanAllowList } from './constants'; +import { NextVanillaSpanAllowlist } from './constants'; +const isPromise = (p)=>{ + return p !== null && typeof p === 'object' && typeof p.then === 'function'; +}; +const closeSpanWithError = (span, error)=>{ + if (isBubbledError(error) && error.bubble) { + span.setAttribute('next.bubble', true); + } else { + if (error) { + span.recordException(error); + } + span.setStatus({ + code: SpanStatusCode.ERROR, + message: error == null ? void 0 : error.message + }); + } + span.end(); +}; +const rootSpanIdKey = api.createContextKey('next.rootSpanId'); +let lastSpanId = 0; +const getSpanId = ()=>lastSpanId++; +const clientTraceDataSetter = { + set (carrier, key, value) { + carrier.push({ + key, + value + }); + } +}; +class NextTracerImpl { + getTracerInstance() { + return trace.getTracer('next.js', '0.0.1'); + } + getContext() { + return context; + } + getTracePropagationData() { + const activeContext = context.active(); + const entries = []; + propagation.inject(activeContext, entries, clientTraceDataSetter); + return entries; + } + getActiveScopeSpan() { + return trace.getSpan(context == null ? void 0 : context.active()); + } + withPropagatedContext(carrier, fn, getter) { + const activeContext = context.active(); + if (trace.getSpanContext(activeContext)) { + return fn(); + } + const remoteContext = propagation.extract(activeContext, carrier, getter); + return context.with(remoteContext, fn); + } + trace(...args) { + var _trace_getSpanContext; + const [type, fnOrOptions, fnOrEmpty] = args; + const { fn, options } = typeof fnOrOptions === 'function' ? { + fn: fnOrOptions, + options: {} + } : { + fn: fnOrEmpty, + options: { + ...fnOrOptions + } + }; + const spanName = options.spanName ?? type; + if (!NextVanillaSpanAllowlist.includes(type) && process.env.NEXT_OTEL_VERBOSE !== '1' || options.hideSpan) { + return fn(); + } + let spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan()); + let isRootSpan = false; + if (!spanContext) { + spanContext = (context == null ? void 0 : context.active()) ?? ROOT_CONTEXT; + isRootSpan = true; + } else if ((_trace_getSpanContext = trace.getSpanContext(spanContext)) == null ? void 0 : _trace_getSpanContext.isRemote) { + isRootSpan = true; + } + const spanId = getSpanId(); + options.attributes = { + 'next.span_name': spanName, + 'next.span_type': type, + ...options.attributes + }; + return context.with(spanContext.setValue(rootSpanIdKey, spanId), ()=>this.getTracerInstance().startActiveSpan(spanName, options, (span)=>{ + const startTime = 'performance' in globalThis && 'measure' in performance ? globalThis.performance.now() : undefined; + const onCleanup = ()=>{ + rootSpanAttributesStore.delete(spanId); + if (startTime && process.env.NEXT_OTEL_PERFORMANCE_PREFIX && LogSpanAllowList.includes(type || '')) { + performance.measure(`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-${(type.split('.').pop() || '').replace(/[A-Z]/g, (match)=>'-' + match.toLowerCase())}`, { + start: startTime, + end: performance.now() + }); + } + }; + if (isRootSpan) { + rootSpanAttributesStore.set(spanId, new Map(Object.entries(options.attributes ?? {}))); + } + try { + if (fn.length > 1) { + return fn(span, (err)=>closeSpanWithError(span, err)); + } + const result = fn(span); + if (isPromise(result)) { + return result.then((res)=>{ + span.end(); + return res; + }).catch((err)=>{ + closeSpanWithError(span, err); + throw err; + }).finally(onCleanup); + } else { + span.end(); + onCleanup(); + } + return result; + } catch (err) { + closeSpanWithError(span, err); + onCleanup(); + throw err; + } + })); + } + wrap(...args) { + const tracer = this; + const [name, options, fn] = args.length === 3 ? args : [ + args[0], + {}, + args[1] + ]; + if (!NextVanillaSpanAllowlist.includes(name) && process.env.NEXT_OTEL_VERBOSE !== '1') { + return fn; + } + return function() { + let optionsObj = options; + if (typeof optionsObj === 'function' && typeof fn === 'function') { + optionsObj = optionsObj.apply(this, arguments); + } + const lastArgId = arguments.length - 1; + const cb = arguments[lastArgId]; + if (typeof cb === 'function') { + const scopeBoundCb = tracer.getContext().bind(context.active(), cb); + return tracer.trace(name, optionsObj, (_span, done)=>{ + arguments[lastArgId] = function(err) { + done == null ? void 0 : done(err); + return scopeBoundCb.apply(this, arguments); + }; + return fn.apply(this, arguments); + }); + } else { + return tracer.trace(name, optionsObj, ()=>fn.apply(this, arguments)); + } + }; + } + startSpan(...args) { + const [type, options] = args; + const spanContext = this.getSpanContext((options == null ? void 0 : options.parentSpan) ?? this.getActiveScopeSpan()); + return this.getTracerInstance().startSpan(type, options, spanContext); + } + getSpanContext(parentSpan) { + const spanContext = parentSpan ? trace.setSpan(context.active(), parentSpan) : undefined; + return spanContext; + } + getRootSpanAttributes() { + const spanId = context.active().getValue(rootSpanIdKey); + return rootSpanAttributesStore.get(spanId); } } +const getTracer = (()=>{ + const tracer = new NextTracerImpl(); + return ()=>tracer; +})(); +export { LogSpanAllowList } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { NextVanillaSpanAllowlist } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { isPromise } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { closeSpanWithError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { rootSpanIdKey } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { lastSpanId } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { getSpanId } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { clientTraceDataSetter } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { NextTracerImpl } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { getTracer } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; ``` -## Merged (module eval) +## Part 4 +```js +import { SpanStatusCode } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +export { SpanStatusCode as SpanStatusCode }; + +``` +## Part 5 +```js +import { SpanKind } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +export { SpanKind as SpanKind }; + +``` +## Part 6 ```js import './constants'; -"module evaluation"; + +``` +## Part 7 +```js +let api; +export { api } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 8 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; if (process.env.NEXT_RUNTIME === 'edge') { api = require('@opentelemetry/api'); } else { @@ -226,3 +1465,88 @@ if (process.env.NEXT_RUNTIME === 'edge') { } ``` +## Part 9 +```js +import { api } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +const { context, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = api; +export { context } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { propagation } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { trace } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { SpanStatusCode } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { SpanKind } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { ROOT_CONTEXT } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 10 +```js +class BubbledError extends Error { + constructor(bubble, result){ + super(); + this.bubble = bubble; + this.result = result; + } +} +export { BubbledError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 11 +```js +import { BubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; +function isBubbledError(error) { + if (typeof error !== 'object' || error === null) return false; + return error instanceof BubbledError; +} +export { isBubbledError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 12 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +const rootSpanAttributesStore = new Map(); +export { rootSpanAttributesStore } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Merged (module eval) +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 12 +}; +"module evaluation"; + +``` From 45fb46ba04adc0e32925c3cd89863e04ed6544ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Thu, 20 Jun 2024 08:30:50 +0900 Subject: [PATCH 019/154] Make more access not eventual --- .../src/tree_shake/graph.rs | 32 ++++++++++++------- .../src/tree_shake/util.rs | 14 +++----- 2 files changed, 24 insertions(+), 22 deletions(-) diff --git a/crates/turbopack-ecmascript/src/tree_shake/graph.rs b/crates/turbopack-ecmascript/src/tree_shake/graph.rs index 6020faaa0d487..ff1953eab10d2 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/graph.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/graph.rs @@ -26,7 +26,9 @@ use swc_core::{ use turbo_tasks::RcStr; use super::{ - util::{collect_top_level_decls, ids_captured_by, ids_used_by, ids_used_by_ignoring_nested}, + util::{ + collect_top_level_decls, ids_captured_by, ids_used_by, ids_used_by_ignoring_nested, Vars, + }, Key, TURBOPACK_PART_IMPORT_SOURCE, }; use crate::magic_identifier; @@ -917,20 +919,20 @@ impl DepGraph { }; ids.push(id.clone()); - let vars = + let mut vars = ids_used_by(&c.class, unresolved_ctxt, top_level_ctxt, &top_level_vars); let var_decls = { let mut v = IndexSet::with_capacity_and_hasher(1, Default::default()); v.insert(c.ident.to_id()); v }; + vars.write.insert(c.ident.to_id()); items.insert( id, ItemData { is_hoisted: true, - eventual_read_vars: vars.read, - eventual_write_vars: vars.write, - write_vars: var_decls.clone(), + read_vars: vars.read, + write_vars: vars.write, var_decls, content: ModuleItem::Stmt(Stmt::Decl(Decl::Class(c.clone()))), ..Default::default() @@ -950,18 +952,24 @@ impl DepGraph { ids.push(id.clone()); let decl_ids: Vec = find_pat_ids(&decl.name); - let vars = ids_used_by_ignoring_nested( - &decl.init, - unresolved_ctxt, - top_level_ctxt, - &top_level_vars, - ); - let eventual_vars = ids_captured_by( + let vars = ids_used_by( &decl.init, unresolved_ctxt, top_level_ctxt, &top_level_vars, ); + let eventual_vars = + if matches!(decl.init.as_deref(), Some(Expr::Fn(..) | Expr::Arrow(..))) + { + ids_captured_by( + &decl.init, + unresolved_ctxt, + top_level_ctxt, + &top_level_vars, + ) + } else { + Vars::default() + }; let side_effects = vars.found_unresolved; diff --git a/crates/turbopack-ecmascript/src/tree_shake/util.rs b/crates/turbopack-ecmascript/src/tree_shake/util.rs index d41ba35e4024b..78b26880ab627 100644 --- a/crates/turbopack-ecmascript/src/tree_shake/util.rs +++ b/crates/turbopack-ecmascript/src/tree_shake/util.rs @@ -6,10 +6,10 @@ use swc_core::{ common::SyntaxContext, ecma::{ ast::{ - ArrowExpr, AssignPatProp, AssignTarget, BlockStmtOrExpr, ClassDecl, ClassExpr, - Constructor, DefaultDecl, ExportDefaultDecl, ExportNamedSpecifier, ExportSpecifier, - Expr, FnDecl, FnExpr, Function, Id, Ident, ImportSpecifier, MemberExpr, MemberProp, - NamedExport, Param, Pat, PropName, VarDeclarator, + ArrowExpr, AssignPatProp, AssignTarget, ClassDecl, ClassExpr, Constructor, DefaultDecl, + ExportDefaultDecl, ExportNamedSpecifier, ExportSpecifier, Expr, FnDecl, FnExpr, + Function, Id, Ident, ImportSpecifier, MemberExpr, MemberProp, NamedExport, Param, Pat, + PropName, VarDeclarator, }, visit::{noop_visit_type, Visit, VisitWith}, }, @@ -68,12 +68,6 @@ impl Visit for IdentUsageCollector<'_> { }) } - fn visit_block_stmt_or_expr(&mut self, n: &BlockStmtOrExpr) { - self.with_nested(|this| { - n.visit_children_with(this); - }) - } - fn visit_constructor(&mut self, n: &Constructor) { self.with_nested(|this| { n.visit_children_with(this); From b7129b40b527252f905ca5cf45c7ee5d2110f3c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Thu, 20 Jun 2024 08:31:02 +0900 Subject: [PATCH 020/154] Update test refs --- .../tree-shaker/analyzer/failed-3/output.md | 170 ++++- .../analyzer/ipc-evaluate/output.md | 84 ++- .../tree-shaker/analyzer/ipc-index/output.md | 170 ++++- .../analyzer/nextjs-tracer/output.md | 644 ++++++------------ 4 files changed, 542 insertions(+), 526 deletions(-) diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/failed-3/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/failed-3/output.md index 5220a3ffac6a3..ac23a4a44c8dc 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/failed-3/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/failed-3/output.md @@ -251,8 +251,8 @@ process.on("uncaughtException", (err)=>{ ``` - Side effects -- Reads (eventual): `IPC` -- Write (eventual): `IPC` +- Reads: `IPC` +- Write: `IPC` ## Item 12: Stmt 8, `VarDeclarator(0)` @@ -274,6 +274,7 @@ const improveConsole = (name, stream, addStack)=>{ ``` +- Side effects - Declares: `improveConsole` - Write: `improveConsole` @@ -534,15 +535,25 @@ graph TD Item10 -.-> Item5; Item10 -.-> Item4; Item10 -.-> Item7; + Item11 --> Item10; Item11 --> Item1; Item11 --> Item2; Item11 --> Item3; Item11 --> Item9; - Item11 --> Item10; Item11 -.-> Item6; Item11 -.-> Item5; Item11 -.-> Item4; Item11 -.-> Item7; + Item12 --> Item1; + Item12 --> Item2; + Item12 --> Item3; + Item12 --> Item9; + Item12 --> Item10; + Item12 --> Item11; + Item12 -.-> Item6; + Item12 -.-> Item5; + Item12 -.-> Item4; + Item12 -.-> Item7; Item13 --> Item12; Item13 --> Item1; Item13 --> Item2; @@ -841,6 +852,7 @@ graph TD Item28 -.-> Item7; Item30 --> Item7; Item31 --> Item10; + Item31 --> Item11; ``` # Phase 3 ```mermaid @@ -898,15 +910,25 @@ graph TD Item10 -.-> Item5; Item10 -.-> Item4; Item10 -.-> Item7; + Item11 --> Item10; Item11 --> Item1; Item11 --> Item2; Item11 --> Item3; Item11 --> Item9; - Item11 --> Item10; Item11 -.-> Item6; Item11 -.-> Item5; Item11 -.-> Item4; Item11 -.-> Item7; + Item12 --> Item1; + Item12 --> Item2; + Item12 --> Item3; + Item12 --> Item9; + Item12 --> Item10; + Item12 --> Item11; + Item12 -.-> Item6; + Item12 -.-> Item5; + Item12 -.-> Item4; + Item12 -.-> Item7; Item13 --> Item12; Item13 --> Item1; Item13 --> Item2; @@ -1205,11 +1227,11 @@ graph TD Item28 -.-> Item7; Item30 --> Item7; Item31 --> Item10; + Item31 --> Item11; Item7 --> Item6; Item7 --> Item5; Item8 --> Item4; Item8 --> Item7; - Item11 -.-> Item31; ``` # Phase 4 ```mermaid @@ -1267,15 +1289,25 @@ graph TD Item10 -.-> Item5; Item10 -.-> Item4; Item10 -.-> Item7; + Item11 --> Item10; Item11 --> Item1; Item11 --> Item2; Item11 --> Item3; Item11 --> Item9; - Item11 --> Item10; Item11 -.-> Item6; Item11 -.-> Item5; Item11 -.-> Item4; Item11 -.-> Item7; + Item12 --> Item1; + Item12 --> Item2; + Item12 --> Item3; + Item12 --> Item9; + Item12 --> Item10; + Item12 --> Item11; + Item12 -.-> Item6; + Item12 -.-> Item5; + Item12 -.-> Item4; + Item12 -.-> Item7; Item13 --> Item12; Item13 --> Item1; Item13 --> Item2; @@ -1574,17 +1606,18 @@ graph TD Item28 -.-> Item7; Item30 --> Item7; Item31 --> Item10; + Item31 --> Item11; Item7 --> Item6; Item7 --> Item5; Item8 --> Item4; Item8 --> Item7; - Item11 -.-> Item31; Item29 --> Item1; Item29 --> Item2; Item29 --> Item3; Item29 --> Item9; Item29 --> Item10; Item29 --> Item11; + Item29 --> Item12; Item29 --> Item13; Item29 --> Item14; Item29 --> Item15; @@ -1605,7 +1638,7 @@ graph TD # Final ```mermaid graph TD - N0["Items: [ItemId(ModuleEvaluation), ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(7, Normal), ItemId(8, VarDeclarator(0)), ItemId(9, Normal), ItemId(10, Normal), ItemId(11, Normal), ItemId(12, Normal), ItemId(13, Normal), ItemId(14, Normal), ItemId(15, Normal), ItemId(16, Normal), ItemId(17, Normal), ItemId(18, Normal), ItemId(19, Normal), ItemId(20, Normal), ItemId(21, Normal), ItemId(22, Normal), ItemId(23, Normal), ItemId(24, Normal)]"]; + N0["Items: [ItemId(ModuleEvaluation), ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(8, VarDeclarator(0)), ItemId(9, Normal), ItemId(10, Normal), ItemId(11, Normal), ItemId(12, Normal), ItemId(13, Normal), ItemId(14, Normal), ItemId(15, Normal), ItemId(16, Normal), ItemId(17, Normal), ItemId(18, Normal), ItemId(19, Normal), ItemId(20, Normal), ItemId(21, Normal), ItemId(22, Normal), ItemId(23, Normal), ItemId(24, Normal)]"]; N1["Items: [ItemId(Export(("structuredError", #2), "structuredError"))]"]; N2["Items: [ItemId(Export(("IPC", #2), "IPC"))]"]; N3["Items: [ItemId(0, ImportOfModule)]"]; @@ -1614,29 +1647,38 @@ graph TD N6["Items: [ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(3, Normal)]"]; N7["Items: [ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(5, VarDeclarator(0))]"]; N8["Items: [ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(4, Normal), ItemId(6, VarDeclarator(0))]"]; + N9["Items: [ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(7, Normal)]"]; N0 --> N3; N0 --> N4; N0 --> N5; N0 --> N7; N0 --> N8; + N0 --> N9; N0 --> N6; - N0 --> N2; N1 --> N6; N2 --> N8; + N2 --> N9; N4 --> N3; N5 --> N3; N5 --> N4; - N6 --> N8; + N6 --> N9; N7 --> N3; N7 --> N4; N7 --> N5; - N7 --> N8; + N7 --> N9; N7 --> N6; + N8 --> N9; N8 --> N6; N8 --> N7; N8 --> N3; N8 --> N4; N8 --> N5; + N9 --> N8; + N9 --> N3; + N9 --> N4; + N9 --> N5; + N9 --> N7; + N9 --> N6; ``` # Entrypoints @@ -1668,22 +1710,19 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; -import { IPC } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 + __turbopack_part__: 9 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 2 + __turbopack_part__: 6 }; "module evaluation"; import { createConnection } from "node:net"; import { parse as parseStackTrace } from "../compiled/stacktrace-parser"; import { getProperError } from "./error"; -process.on("uncaughtException", (err)=>{ - IPC.sendError(err); -}); const improveConsole = (name, stream, addStack)=>{ const original = console[name]; const stdio = process[stream]; @@ -1741,6 +1780,9 @@ export { structuredError }; import { IPC } from "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { IPC }; ``` @@ -1771,7 +1813,7 @@ import "./error"; ## Part 6 ```js import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 + __turbopack_part__: 9 }; import { parse as parseStackTrace } from "../compiled/stacktrace-parser"; import { getProperError } from "./error"; @@ -1806,7 +1848,7 @@ import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 + __turbopack_part__: 9 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 @@ -1831,6 +1873,9 @@ export { PORT } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; import { structuredError } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; @@ -1992,6 +2037,43 @@ export { IPC } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; +``` +## Part 9 +```js +import { IPC } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import { createConnection } from "node:net"; +import { parse as parseStackTrace } from "../compiled/stacktrace-parser"; +import { getProperError } from "./error"; +process.on("uncaughtException", (err)=>{ + IPC.sendError(err); +}); +export { createConnection } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { parseStackTrace } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { getProperError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + ``` ## Merged (module eval) ```js @@ -2007,22 +2089,19 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; -import { IPC } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 + __turbopack_part__: 9 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 2 + __turbopack_part__: 6 }; import { createConnection } from "node:net"; import { parse as parseStackTrace } from "../compiled/stacktrace-parser"; import { getProperError } from "./error"; "module evaluation"; -process.on("uncaughtException", (err)=>{ - IPC.sendError(err); -}); const improveConsole = (name, stream, addStack)=>{ const original = console[name]; const stdio = process[stream]; @@ -2097,13 +2176,13 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; -import { IPC } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; "module evaluation"; -process.on("uncaughtException", (err)=>{ - IPC.sendError(err); -}); const improveConsole = (name, stream, addStack)=>{ const original = console[name]; const stdio = process[stream]; @@ -2152,6 +2231,9 @@ export { structuredError }; import { IPC } from "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { IPC }; ``` @@ -2374,6 +2456,28 @@ export { IPC } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; +``` +## Part 9 +```js +import { IPC } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +process.on("uncaughtException", (err)=>{ + IPC.sendError(err); +}); + ``` ## Merged (module eval) ```js @@ -2389,13 +2493,13 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; -import { IPC } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; "module evaluation"; -process.on("uncaughtException", (err)=>{ - IPC.sendError(err); -}); const improveConsole = (name, stream, addStack)=>{ const original = console[name]; const stdio = process[stream]; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/ipc-evaluate/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/ipc-evaluate/output.md index adbe2ec572da3..aefe991402113 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/ipc-evaluate/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/ipc-evaluate/output.md @@ -140,10 +140,10 @@ export const run = async (moduleFactory)=>{ ``` +- Side effects - Declares: `run` -- Reads (eventual): `ipc`, `queue` -- Write: `run` -- Write (eventual): `ipc`, `queue` +- Reads: `ipc`, `queue` +- Write: `run`, `ipc`, `queue` # Phase 1 ```mermaid @@ -171,6 +171,9 @@ graph TD Item7; Item7["export run"]; Item3 --> Item2; + Item5 --> Item3; + Item5 --> Item4; + Item5 --> Item1; Item7 --> Item5; ``` # Phase 3 @@ -186,9 +189,10 @@ graph TD Item7; Item7["export run"]; Item3 --> Item2; - Item7 --> Item5; Item5 --> Item3; Item5 --> Item4; + Item5 --> Item1; + Item7 --> Item5; ``` # Phase 4 ```mermaid @@ -203,16 +207,24 @@ graph TD Item7; Item7["export run"]; Item3 --> Item2; - Item7 --> Item5; Item5 --> Item3; Item5 --> Item4; + Item5 --> Item1; + Item7 --> Item5; Item6 --> Item1; + Item6 --> Item5; ``` # Final ```mermaid graph TD - N0["Items: [ItemId(ModuleEvaluation), ItemId(0, ImportOfModule)]"]; - N1["Items: [ItemId(Export(("run", #2), "run")), ItemId(0, ImportBinding(0)), ItemId(1, VarDeclarator(0)), ItemId(2, VarDeclarator(0)), ItemId(3, VarDeclarator(0))]"]; + N0["Items: [ItemId(ModuleEvaluation)]"]; + N1["Items: [ItemId(Export(("run", #2), "run"))]"]; + N2["Items: [ItemId(0, ImportOfModule)]"]; + N3["Items: [ItemId(0, ImportBinding(0)), ItemId(1, VarDeclarator(0)), ItemId(2, VarDeclarator(0)), ItemId(3, VarDeclarator(0))]"]; + N0 --> N2; + N0 --> N3; + N1 --> N3; + N3 --> N2; ``` # Entrypoints @@ -229,13 +241,33 @@ graph TD # Modules (dev) ## Part 0 ```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; "module evaluation"; -import "./index"; ``` ## Part 1 ```js +import { run } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; export { run }; + +``` +## Part 2 +```js +import "./index"; + +``` +## Part 3 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; import { IPC } from "./index"; const ipc = IPC; const queue = []; @@ -346,7 +378,12 @@ export { run } from "__TURBOPACK_VAR__" assert { ``` ## Merged (module eval) ```js -import "./index"; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; "module evaluation"; ``` @@ -365,13 +402,33 @@ import "./index"; # Modules (prod) ## Part 0 ```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; "module evaluation"; -import "./index"; ``` ## Part 1 ```js +import { run } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; export { run }; + +``` +## Part 2 +```js +import "./index"; + +``` +## Part 3 +```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; import { IPC } from "./index"; const ipc = IPC; const queue = []; @@ -482,7 +539,12 @@ export { run } from "__TURBOPACK_VAR__" assert { ``` ## Merged (module eval) ```js -import "./index"; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 2 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; "module evaluation"; ``` diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/ipc-index/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/ipc-index/output.md index 5220a3ffac6a3..ac23a4a44c8dc 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/ipc-index/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/ipc-index/output.md @@ -251,8 +251,8 @@ process.on("uncaughtException", (err)=>{ ``` - Side effects -- Reads (eventual): `IPC` -- Write (eventual): `IPC` +- Reads: `IPC` +- Write: `IPC` ## Item 12: Stmt 8, `VarDeclarator(0)` @@ -274,6 +274,7 @@ const improveConsole = (name, stream, addStack)=>{ ``` +- Side effects - Declares: `improveConsole` - Write: `improveConsole` @@ -534,15 +535,25 @@ graph TD Item10 -.-> Item5; Item10 -.-> Item4; Item10 -.-> Item7; + Item11 --> Item10; Item11 --> Item1; Item11 --> Item2; Item11 --> Item3; Item11 --> Item9; - Item11 --> Item10; Item11 -.-> Item6; Item11 -.-> Item5; Item11 -.-> Item4; Item11 -.-> Item7; + Item12 --> Item1; + Item12 --> Item2; + Item12 --> Item3; + Item12 --> Item9; + Item12 --> Item10; + Item12 --> Item11; + Item12 -.-> Item6; + Item12 -.-> Item5; + Item12 -.-> Item4; + Item12 -.-> Item7; Item13 --> Item12; Item13 --> Item1; Item13 --> Item2; @@ -841,6 +852,7 @@ graph TD Item28 -.-> Item7; Item30 --> Item7; Item31 --> Item10; + Item31 --> Item11; ``` # Phase 3 ```mermaid @@ -898,15 +910,25 @@ graph TD Item10 -.-> Item5; Item10 -.-> Item4; Item10 -.-> Item7; + Item11 --> Item10; Item11 --> Item1; Item11 --> Item2; Item11 --> Item3; Item11 --> Item9; - Item11 --> Item10; Item11 -.-> Item6; Item11 -.-> Item5; Item11 -.-> Item4; Item11 -.-> Item7; + Item12 --> Item1; + Item12 --> Item2; + Item12 --> Item3; + Item12 --> Item9; + Item12 --> Item10; + Item12 --> Item11; + Item12 -.-> Item6; + Item12 -.-> Item5; + Item12 -.-> Item4; + Item12 -.-> Item7; Item13 --> Item12; Item13 --> Item1; Item13 --> Item2; @@ -1205,11 +1227,11 @@ graph TD Item28 -.-> Item7; Item30 --> Item7; Item31 --> Item10; + Item31 --> Item11; Item7 --> Item6; Item7 --> Item5; Item8 --> Item4; Item8 --> Item7; - Item11 -.-> Item31; ``` # Phase 4 ```mermaid @@ -1267,15 +1289,25 @@ graph TD Item10 -.-> Item5; Item10 -.-> Item4; Item10 -.-> Item7; + Item11 --> Item10; Item11 --> Item1; Item11 --> Item2; Item11 --> Item3; Item11 --> Item9; - Item11 --> Item10; Item11 -.-> Item6; Item11 -.-> Item5; Item11 -.-> Item4; Item11 -.-> Item7; + Item12 --> Item1; + Item12 --> Item2; + Item12 --> Item3; + Item12 --> Item9; + Item12 --> Item10; + Item12 --> Item11; + Item12 -.-> Item6; + Item12 -.-> Item5; + Item12 -.-> Item4; + Item12 -.-> Item7; Item13 --> Item12; Item13 --> Item1; Item13 --> Item2; @@ -1574,17 +1606,18 @@ graph TD Item28 -.-> Item7; Item30 --> Item7; Item31 --> Item10; + Item31 --> Item11; Item7 --> Item6; Item7 --> Item5; Item8 --> Item4; Item8 --> Item7; - Item11 -.-> Item31; Item29 --> Item1; Item29 --> Item2; Item29 --> Item3; Item29 --> Item9; Item29 --> Item10; Item29 --> Item11; + Item29 --> Item12; Item29 --> Item13; Item29 --> Item14; Item29 --> Item15; @@ -1605,7 +1638,7 @@ graph TD # Final ```mermaid graph TD - N0["Items: [ItemId(ModuleEvaluation), ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(7, Normal), ItemId(8, VarDeclarator(0)), ItemId(9, Normal), ItemId(10, Normal), ItemId(11, Normal), ItemId(12, Normal), ItemId(13, Normal), ItemId(14, Normal), ItemId(15, Normal), ItemId(16, Normal), ItemId(17, Normal), ItemId(18, Normal), ItemId(19, Normal), ItemId(20, Normal), ItemId(21, Normal), ItemId(22, Normal), ItemId(23, Normal), ItemId(24, Normal)]"]; + N0["Items: [ItemId(ModuleEvaluation), ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(8, VarDeclarator(0)), ItemId(9, Normal), ItemId(10, Normal), ItemId(11, Normal), ItemId(12, Normal), ItemId(13, Normal), ItemId(14, Normal), ItemId(15, Normal), ItemId(16, Normal), ItemId(17, Normal), ItemId(18, Normal), ItemId(19, Normal), ItemId(20, Normal), ItemId(21, Normal), ItemId(22, Normal), ItemId(23, Normal), ItemId(24, Normal)]"]; N1["Items: [ItemId(Export(("structuredError", #2), "structuredError"))]"]; N2["Items: [ItemId(Export(("IPC", #2), "IPC"))]"]; N3["Items: [ItemId(0, ImportOfModule)]"]; @@ -1614,29 +1647,38 @@ graph TD N6["Items: [ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(3, Normal)]"]; N7["Items: [ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(5, VarDeclarator(0))]"]; N8["Items: [ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(4, Normal), ItemId(6, VarDeclarator(0))]"]; + N9["Items: [ItemId(0, ImportBinding(0)), ItemId(1, ImportBinding(0)), ItemId(2, ImportBinding(0)), ItemId(7, Normal)]"]; N0 --> N3; N0 --> N4; N0 --> N5; N0 --> N7; N0 --> N8; + N0 --> N9; N0 --> N6; - N0 --> N2; N1 --> N6; N2 --> N8; + N2 --> N9; N4 --> N3; N5 --> N3; N5 --> N4; - N6 --> N8; + N6 --> N9; N7 --> N3; N7 --> N4; N7 --> N5; - N7 --> N8; + N7 --> N9; N7 --> N6; + N8 --> N9; N8 --> N6; N8 --> N7; N8 --> N3; N8 --> N4; N8 --> N5; + N9 --> N8; + N9 --> N3; + N9 --> N4; + N9 --> N5; + N9 --> N7; + N9 --> N6; ``` # Entrypoints @@ -1668,22 +1710,19 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; -import { IPC } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 + __turbopack_part__: 9 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 2 + __turbopack_part__: 6 }; "module evaluation"; import { createConnection } from "node:net"; import { parse as parseStackTrace } from "../compiled/stacktrace-parser"; import { getProperError } from "./error"; -process.on("uncaughtException", (err)=>{ - IPC.sendError(err); -}); const improveConsole = (name, stream, addStack)=>{ const original = console[name]; const stdio = process[stream]; @@ -1741,6 +1780,9 @@ export { structuredError }; import { IPC } from "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { IPC }; ``` @@ -1771,7 +1813,7 @@ import "./error"; ## Part 6 ```js import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 + __turbopack_part__: 9 }; import { parse as parseStackTrace } from "../compiled/stacktrace-parser"; import { getProperError } from "./error"; @@ -1806,7 +1848,7 @@ import "__TURBOPACK_PART__" assert { __turbopack_part__: 5 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 + __turbopack_part__: 9 }; import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 @@ -1831,6 +1873,9 @@ export { PORT } from "__TURBOPACK_VAR__" assert { ``` ## Part 8 ```js +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; import { structuredError } from "__TURBOPACK_PART__" assert { __turbopack_part__: 6 }; @@ -1992,6 +2037,43 @@ export { IPC } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; +``` +## Part 9 +```js +import { IPC } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import { createConnection } from "node:net"; +import { parse as parseStackTrace } from "../compiled/stacktrace-parser"; +import { getProperError } from "./error"; +process.on("uncaughtException", (err)=>{ + IPC.sendError(err); +}); +export { createConnection } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { parseStackTrace } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { getProperError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + ``` ## Merged (module eval) ```js @@ -2007,22 +2089,19 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; -import { IPC } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 + __turbopack_part__: 9 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 2 + __turbopack_part__: 6 }; import { createConnection } from "node:net"; import { parse as parseStackTrace } from "../compiled/stacktrace-parser"; import { getProperError } from "./error"; "module evaluation"; -process.on("uncaughtException", (err)=>{ - IPC.sendError(err); -}); const improveConsole = (name, stream, addStack)=>{ const original = console[name]; const stdio = process[stream]; @@ -2097,13 +2176,13 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; -import { IPC } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; "module evaluation"; -process.on("uncaughtException", (err)=>{ - IPC.sendError(err); -}); const improveConsole = (name, stream, addStack)=>{ const original = console[name]; const stdio = process[stream]; @@ -2152,6 +2231,9 @@ export { structuredError }; import { IPC } from "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; export { IPC }; ``` @@ -2374,6 +2456,28 @@ export { IPC } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; +``` +## Part 9 +```js +import { IPC } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 3 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 4 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 5 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +process.on("uncaughtException", (err)=>{ + IPC.sendError(err); +}); + ``` ## Merged (module eval) ```js @@ -2389,13 +2493,13 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 7 }; -import { IPC } from "__TURBOPACK_PART__" assert { +import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; "module evaluation"; -process.on("uncaughtException", (err)=>{ - IPC.sendError(err); -}); const improveConsole = (name, stream, addStack)=>{ const original = console[name]; const stdio = process[stream]; diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md index 07071e286bc19..53b926d8a1983 100644 --- a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/nextjs-tracer/output.md @@ -136,9 +136,8 @@ const closeSpanWithError = (span, error)=>{ ``` - Declares: `closeSpanWithError` -- Reads (eventual): `isBubbledError`, `SpanStatusCode` -- Write: `closeSpanWithError` -- Write (eventual): `SpanStatusCode` +- Reads: `isBubbledError`, `SpanStatusCode` +- Write: `closeSpanWithError`, `SpanStatusCode` ## Item 11: Stmt 8, `VarDeclarator(0)` @@ -180,7 +179,7 @@ const getSpanId = ()=>lastSpanId++; ``` - Declares: `getSpanId` -- Reads (eventual): `lastSpanId` +- Reads: `lastSpanId` - Write: `getSpanId` ## Item 15: Stmt 12, `VarDeclarator(0)` @@ -346,9 +345,8 @@ class NextTracerImpl { - Hoisted - Declares: `NextTracerImpl` -- Reads (eventual): `trace`, `context`, `propagation`, `clientTraceDataSetter`, `NextVanillaSpanAllowlist`, `ROOT_CONTEXT`, `getSpanId`, `rootSpanIdKey`, `rootSpanAttributesStore`, `LogSpanAllowList`, `closeSpanWithError`, `isPromise` -- Write: `NextTracerImpl` -- Write (eventual): `trace`, `context`, `propagation`, `NextVanillaSpanAllowlist`, `rootSpanAttributesStore`, `LogSpanAllowList` +- Reads: `trace`, `context`, `propagation`, `clientTraceDataSetter`, `NextVanillaSpanAllowlist`, `ROOT_CONTEXT`, `getSpanId`, `rootSpanIdKey`, `rootSpanAttributesStore`, `LogSpanAllowList`, `closeSpanWithError`, `isPromise` +- Write: `trace`, `context`, `propagation`, `NextVanillaSpanAllowlist`, `rootSpanAttributesStore`, `LogSpanAllowList`, `NextTracerImpl` ## Item 17: Stmt 14, `VarDeclarator(0)` @@ -361,7 +359,7 @@ const getTracer = (()=>{ ``` - Declares: `getTracer` -- Reads (eventual): `NextTracerImpl` +- Reads: `NextTracerImpl` - Write: `getTracer` # Phase 1 @@ -432,29 +430,23 @@ graph TD Item5 -.-> Item4; Item5 --> Item1; Item5 -.-> Item8; - Item5 -.-> Item9; - Item5 -.-> Item3; - Item5 -.-> Item2; - Item5 -.-> Item16; Item6 --> Item4; Item6 --> Item5; + Item10 --> Item9; + Item10 --> Item6; Item11 --> Item1; Item11 --> Item5; Item11 -.-> Item8; - Item11 -.-> Item9; - Item11 -.-> Item6; - Item11 -.-> Item3; - Item11 -.-> Item2; - Item11 -.-> Item10; - Item11 -.-> Item7; - Item11 -.-> Item16; Item12 --> Item4; Item12 --> Item5; Item12 -.-> Item6; + Item14 --> Item13; + Item17 --> Item16; Item19 --> Item8; Item20 --> Item9; Item21 --> Item17; Item22 --> Item6; + Item22 --> Item10; Item23 --> Item6; ``` # Phase 3 @@ -492,45 +484,25 @@ graph TD Item5 -.-> Item4; Item5 --> Item1; Item5 -.-> Item8; - Item5 -.-> Item9; - Item5 -.-> Item3; - Item5 -.-> Item2; - Item5 -.-> Item16; Item6 --> Item4; Item6 --> Item5; + Item10 --> Item9; + Item10 --> Item6; Item11 --> Item1; Item11 --> Item5; Item11 -.-> Item8; - Item11 -.-> Item9; - Item11 -.-> Item6; - Item11 -.-> Item3; - Item11 -.-> Item2; - Item11 -.-> Item10; - Item11 -.-> Item7; - Item11 -.-> Item16; Item12 --> Item4; Item12 --> Item5; Item12 -.-> Item6; + Item14 --> Item13; + Item17 --> Item16; Item19 --> Item8; Item20 --> Item9; Item21 --> Item17; Item22 --> Item6; + Item22 --> Item10; Item23 --> Item6; Item9 --> Item8; - Item10 --> Item9; - Item10 --> Item6; - Item10 -.-> Item22; - Item14 --> Item13; - Item16 --> Item6; - Item16 --> Item15; - Item16 --> Item3; - Item16 --> Item14; - Item16 --> Item12; - Item16 --> Item11; - Item16 --> Item2; - Item16 --> Item10; - Item16 --> Item7; - Item17 --> Item16; ``` # Phase 4 ```mermaid @@ -567,45 +539,25 @@ graph TD Item5 -.-> Item4; Item5 --> Item1; Item5 -.-> Item8; - Item5 -.-> Item9; - Item5 -.-> Item3; - Item5 -.-> Item2; - Item5 -.-> Item16; Item6 --> Item4; Item6 --> Item5; + Item10 --> Item9; + Item10 --> Item6; Item11 --> Item1; Item11 --> Item5; Item11 -.-> Item8; - Item11 -.-> Item9; - Item11 -.-> Item6; - Item11 -.-> Item3; - Item11 -.-> Item2; - Item11 -.-> Item10; - Item11 -.-> Item7; - Item11 -.-> Item16; Item12 --> Item4; Item12 --> Item5; Item12 -.-> Item6; + Item14 --> Item13; + Item17 --> Item16; Item19 --> Item8; Item20 --> Item9; Item21 --> Item17; Item22 --> Item6; + Item22 --> Item10; Item23 --> Item6; Item9 --> Item8; - Item10 --> Item9; - Item10 --> Item6; - Item10 -.-> Item22; - Item14 --> Item13; - Item16 --> Item6; - Item16 --> Item15; - Item16 --> Item3; - Item16 --> Item14; - Item16 --> Item12; - Item16 --> Item11; - Item16 --> Item2; - Item16 --> Item10; - Item16 --> Item7; - Item17 --> Item16; Item18 --> Item1; Item18 --> Item5; Item18 --> Item11; @@ -613,55 +565,32 @@ graph TD # Final ```mermaid graph TD - N0["Items: [ItemId(ModuleEvaluation)]"]; + N0["Items: [ItemId(ModuleEvaluation), ItemId(8, VarDeclarator(0))]"]; N1["Items: [ItemId(Export(("BubbledError", #2), "BubbledError"))]"]; N2["Items: [ItemId(Export(("isBubbledError", #2), "isBubbledError"))]"]; - N3["Items: [ItemId(Export(("getTracer", #2), "getTracer")), ItemId(14, VarDeclarator(0))]"]; - N4["Items: [ItemId(Export(("SpanStatusCode", #2), "SpanStatusCode"))]"]; + N3["Items: [ItemId(Export(("getTracer", #2), "getTracer")), ItemId(13, Normal), ItemId(14, VarDeclarator(0))]"]; + N4["Items: [ItemId(Export(("SpanStatusCode", #2), "SpanStatusCode")), ItemId(7, VarDeclarator(0))]"]; N5["Items: [ItemId(Export(("SpanKind", #2), "SpanKind"))]"]; N6["Items: [ItemId(0, ImportOfModule)]"]; N7["Items: [ItemId(1, VarDeclarator(0))]"]; - N8["Items: [ItemId(0, ImportBinding(0)), ItemId(0, ImportBinding(1)), ItemId(2, Normal)]"]; + N8["Items: [ItemId(2, Normal)]"]; N9["Items: [ItemId(3, VarDeclarator(0))]"]; - N10["Items: [ItemId(4, VarDeclarator(0))]"]; - N11["Items: [ItemId(5, Normal)]"]; - N12["Items: [ItemId(6, Normal)]"]; - N13["Items: [ItemId(7, VarDeclarator(0))]"]; - N14["Items: [ItemId(0, ImportBinding(0)), ItemId(0, ImportBinding(1)), ItemId(8, VarDeclarator(0))]"]; - N15["Items: [ItemId(0, ImportBinding(0)), ItemId(0, ImportBinding(1)), ItemId(9, VarDeclarator(0)), ItemId(10, VarDeclarator(0)), ItemId(11, VarDeclarator(0)), ItemId(12, VarDeclarator(0)), ItemId(13, Normal)]"]; + N10["Items: [ItemId(5, Normal)]"]; + N11["Items: [ItemId(6, Normal)]"]; N0 --> N6; N0 --> N8; - N0 --> N14; - N1 --> N11; - N2 --> N12; - N3 --> N15; + N0 --> N10; + N1 --> N10; + N2 --> N11; N4 --> N9; + N4 --> N11; N5 --> N9; N8 --> N7; N8 --> N6; - N8 --> N11; - N8 --> N12; - N8 --> N15; + N8 --> N10; N9 --> N7; N9 --> N8; - N12 --> N11; - N13 --> N12; - N13 --> N9; - N13 --> N4; - N14 --> N6; - N14 --> N8; - N14 --> N11; - N14 --> N12; - N14 --> N9; - N14 --> N15; - N14 --> N13; - N14 --> N10; - N15 --> N7; - N15 --> N8; - N15 --> N9; - N15 --> N14; - N15 --> N13; - N15 --> N10; + N11 --> N10; ``` # Entrypoints @@ -697,15 +626,19 @@ import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 14 + __turbopack_part__: 10 }; "module evaluation"; +const rootSpanAttributesStore = new Map(); +export { rootSpanAttributesStore } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; ``` ## Part 1 ```js import { BubbledError } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 11 + __turbopack_part__: 10 }; export { BubbledError }; @@ -713,261 +646,14 @@ export { BubbledError }; ## Part 2 ```js import { isBubbledError } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 12 + __turbopack_part__: 11 }; export { isBubbledError }; ``` ## Part 3 ```js -import { NextTracerImpl } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 15 -}; export { getTracer as getTracer }; -const getTracer = (()=>{ - const tracer = new NextTracerImpl(); - return ()=>tracer; -})(); -export { getTracer } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 4 -```js -import { SpanStatusCode } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; -export { SpanStatusCode as SpanStatusCode }; - -``` -## Part 5 -```js -import { SpanKind } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; -export { SpanKind as SpanKind }; - -``` -## Part 6 -```js -import './constants'; - -``` -## Part 7 -```js -let api; -export { api } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 8 -```js -import { api } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 11 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 12 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 15 -}; -import { LogSpanAllowList } from './constants'; -import { NextVanillaSpanAllowlist } from './constants'; -if (process.env.NEXT_RUNTIME === 'edge') { - api = require('@opentelemetry/api'); -} else { - try { - api = require('@opentelemetry/api'); - } catch (err) { - api = require('next/dist/compiled/@opentelemetry/api'); - } -} -export { LogSpanAllowList } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { NextVanillaSpanAllowlist } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 9 -```js -import { api } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; -const { context, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = api; -export { context } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { propagation } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { trace } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { SpanStatusCode } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { SpanKind } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { ROOT_CONTEXT } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 10 -```js -const isPromise = (p)=>{ - return p !== null && typeof p === 'object' && typeof p.then === 'function'; -}; -export { isPromise } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 11 -```js -class BubbledError extends Error { - constructor(bubble, result){ - super(); - this.bubble = bubble; - this.result = result; - } -} -export { BubbledError } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 12 -```js -import { BubbledError } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 11 -}; -function isBubbledError(error) { - if (typeof error !== 'object' || error === null) return false; - return error instanceof BubbledError; -} -export { isBubbledError } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 13 -```js -import { isBubbledError } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 12 -}; -import { SpanStatusCode } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 4 -}; -const closeSpanWithError = (span, error)=>{ - if (isBubbledError(error) && error.bubble) { - span.setAttribute('next.bubble', true); - } else { - if (error) { - span.recordException(error); - } - span.setStatus({ - code: SpanStatusCode.ERROR, - message: error == null ? void 0 : error.message - }); - } - span.end(); -}; -export { closeSpanWithError } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 14 -```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 11 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 12 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 15 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 13 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 10 -}; -import { LogSpanAllowList } from './constants'; -import { NextVanillaSpanAllowlist } from './constants'; -const rootSpanAttributesStore = new Map(); -export { LogSpanAllowList } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { NextVanillaSpanAllowlist } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { rootSpanAttributesStore } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; - -``` -## Part 15 -```js -import { api } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; -import { context, propagation, trace, ROOT_CONTEXT } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; -import { rootSpanAttributesStore } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 14 -}; -import { closeSpanWithError } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 13 -}; -import { isPromise } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 10 -}; -import { LogSpanAllowList } from './constants'; -import { NextVanillaSpanAllowlist } from './constants'; -const rootSpanIdKey = api.createContextKey('next.rootSpanId'); -let lastSpanId = 0; -const getSpanId = ()=>lastSpanId++; -const clientTraceDataSetter = { - set (carrier, key, value) { - carrier.push({ - key, - value - }); - } -}; class NextTracerImpl { getTracerInstance() { return trace.getTracer('next.js', '0.0.1'); @@ -1106,25 +792,142 @@ class NextTracerImpl { return rootSpanAttributesStore.get(spanId); } } -export { LogSpanAllowList } from "__TURBOPACK_VAR__" assert { +const getTracer = (()=>{ + const tracer = new NextTracerImpl(); + return ()=>tracer; +})(); +export { NextTracerImpl } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; +export { getTracer } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 4 +```js +import { SpanStatusCode } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +import { isBubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; +export { SpanStatusCode as SpanStatusCode }; +const closeSpanWithError = (span, error)=>{ + if (isBubbledError(error) && error.bubble) { + span.setAttribute('next.bubble', true); + } else { + if (error) { + span.recordException(error); + } + span.setStatus({ + code: SpanStatusCode.ERROR, + message: error == null ? void 0 : error.message + }); + } + span.end(); +}; +export { closeSpanWithError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 5 +```js +import { SpanKind } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 9 +}; +export { SpanKind as SpanKind }; + +``` +## Part 6 +```js +import './constants'; + +``` +## Part 7 +```js +let api; +export { api } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 8 +```js +import { api } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 6 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; +if (process.env.NEXT_RUNTIME === 'edge') { + api = require('@opentelemetry/api'); +} else { + try { + api = require('@opentelemetry/api'); + } catch (err) { + api = require('next/dist/compiled/@opentelemetry/api'); + } +} + +``` +## Part 9 +```js +import { api } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 7 +}; +import "__TURBOPACK_PART__" assert { + __turbopack_part__: 8 +}; +const { context, propagation, trace, SpanStatusCode, SpanKind, ROOT_CONTEXT } = api; +export { context } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; -export { NextVanillaSpanAllowlist } from "__TURBOPACK_VAR__" assert { +export { propagation } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; -export { rootSpanIdKey } from "__TURBOPACK_VAR__" assert { +export { trace } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; -export { lastSpanId } from "__TURBOPACK_VAR__" assert { +export { SpanStatusCode } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; -export { getSpanId } from "__TURBOPACK_VAR__" assert { +export { SpanKind } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; -export { clientTraceDataSetter } from "__TURBOPACK_VAR__" assert { +export { ROOT_CONTEXT } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; -export { NextTracerImpl } from "__TURBOPACK_VAR__" assert { + +``` +## Part 10 +```js +class BubbledError extends Error { + constructor(bubble, result){ + super(); + this.bubble = bubble; + this.result = result; + } +} +export { BubbledError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; + +``` +## Part 11 +```js +import { BubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 10 +}; +function isBubbledError(error) { + if (typeof error !== 'object' || error === null) return false; + return error instanceof BubbledError; +} +export { isBubbledError } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; @@ -1138,9 +941,13 @@ import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; import "__TURBOPACK_PART__" assert { - __turbopack_part__: 14 + __turbopack_part__: 10 }; "module evaluation"; +const rootSpanAttributesStore = new Map(); +export { rootSpanAttributesStore } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; ``` # Entrypoints @@ -1176,10 +983,11 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 12 -}; "module evaluation"; +const rootSpanAttributesStore = new Map(); +export { rootSpanAttributesStore } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; ``` ## Part 1 @@ -1200,52 +1008,7 @@ export { isBubbledError }; ``` ## Part 3 ```js -import { isBubbledError } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 11 -}; -import { context, propagation, trace, SpanStatusCode, ROOT_CONTEXT } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 9 -}; -import { api } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 7 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; -import { rootSpanAttributesStore } from "__TURBOPACK_PART__" assert { - __turbopack_part__: 12 -}; export { getTracer as getTracer }; -import { LogSpanAllowList } from './constants'; -import { NextVanillaSpanAllowlist } from './constants'; -const isPromise = (p)=>{ - return p !== null && typeof p === 'object' && typeof p.then === 'function'; -}; -const closeSpanWithError = (span, error)=>{ - if (isBubbledError(error) && error.bubble) { - span.setAttribute('next.bubble', true); - } else { - if (error) { - span.recordException(error); - } - span.setStatus({ - code: SpanStatusCode.ERROR, - message: error == null ? void 0 : error.message - }); - } - span.end(); -}; -const rootSpanIdKey = api.createContextKey('next.rootSpanId'); -let lastSpanId = 0; -const getSpanId = ()=>lastSpanId++; -const clientTraceDataSetter = { - set (carrier, key, value) { - carrier.push({ - key, - value - }); - } -}; class NextTracerImpl { getTracerInstance() { return trace.getTracer('next.js', '0.0.1'); @@ -1388,30 +1151,6 @@ const getTracer = (()=>{ const tracer = new NextTracerImpl(); return ()=>tracer; })(); -export { LogSpanAllowList } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { NextVanillaSpanAllowlist } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { isPromise } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { closeSpanWithError } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { rootSpanIdKey } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { lastSpanId } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { getSpanId } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; -export { clientTraceDataSetter } from "__TURBOPACK_VAR__" assert { - __turbopack_var__: true -}; export { NextTracerImpl } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; @@ -1425,7 +1164,27 @@ export { getTracer } from "__TURBOPACK_VAR__" assert { import { SpanStatusCode } from "__TURBOPACK_PART__" assert { __turbopack_part__: 9 }; +import { isBubbledError } from "__TURBOPACK_PART__" assert { + __turbopack_part__: 11 +}; export { SpanStatusCode as SpanStatusCode }; +const closeSpanWithError = (span, error)=>{ + if (isBubbledError(error) && error.bubble) { + span.setAttribute('next.bubble', true); + } else { + if (error) { + span.recordException(error); + } + span.setStatus({ + code: SpanStatusCode.ERROR, + message: error == null ? void 0 : error.message + }); + } + span.end(); +}; +export { closeSpanWithError } from "__TURBOPACK_VAR__" assert { + __turbopack_var__: true +}; ``` ## Part 5 @@ -1522,7 +1281,7 @@ export { isBubbledError } from "__TURBOPACK_VAR__" assert { }; ``` -## Part 12 +## Merged (module eval) ```js import "__TURBOPACK_PART__" assert { __turbopack_part__: 6 @@ -1530,23 +1289,10 @@ import "__TURBOPACK_PART__" assert { import "__TURBOPACK_PART__" assert { __turbopack_part__: 8 }; +"module evaluation"; const rootSpanAttributesStore = new Map(); export { rootSpanAttributesStore } from "__TURBOPACK_VAR__" assert { __turbopack_var__: true }; ``` -## Merged (module eval) -```js -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 6 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 8 -}; -import "__TURBOPACK_PART__" assert { - __turbopack_part__: 12 -}; -"module evaluation"; - -``` From fddbdd7f8b6e425287b4c55d452b018439528bcf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Thu, 20 Jun 2024 08:55:33 +0900 Subject: [PATCH 021/154] Add a test --- .../analyzer/amphtml-document/input.js | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 crates/turbopack-ecmascript/tests/tree-shaker/analyzer/amphtml-document/input.js diff --git a/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/amphtml-document/input.js b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/amphtml-document/input.js new file mode 100644 index 0000000000000..c2974b99747de --- /dev/null +++ b/crates/turbopack-ecmascript/tests/tree-shaker/analyzer/amphtml-document/input.js @@ -0,0 +1,35 @@ +import Document, { Html, Head, Main, NextScript } from 'next/document' + +class MyDocument extends Document { + static async getInitialProps(ctx) { + const initialProps = await Document.getInitialProps(ctx) + + return { + ...initialProps, + styles: ( + <> + {initialProps.styles} +