file_path stringlengths 3 280 | file_language stringclasses 66
values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108
values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
crates/swc_ecma_compat_bugfixes/src/lib.rs | Rust | use swc_common::Mark;
use swc_ecma_ast::Pass;
pub use self::{
async_arrows_in_class::async_arrows_in_class, edge_default_param::edge_default_param,
safari_id_destructuring_collision_in_function_expression::safari_id_destructuring_collision_in_function_expression,
template_literal_caching::template_literal_caching,
};
mod async_arrows_in_class;
mod edge_default_param;
mod safari_id_destructuring_collision_in_function_expression;
mod template_literal_caching;
pub fn bugfixes(unresolved_mark: Mark) -> impl Pass {
(
async_arrows_in_class(unresolved_mark),
edge_default_param(),
template_literal_caching(),
safari_id_destructuring_collision_in_function_expression(),
)
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/src/safari_id_destructuring_collision_in_function_expression.rs | Rust | use std::collections::HashMap;
use rustc_hash::FxHashSet;
use swc_atoms::Atom;
use swc_common::SyntaxContext;
use swc_ecma_ast::*;
use swc_ecma_transforms_base::hygiene::rename;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
pub fn safari_id_destructuring_collision_in_function_expression() -> impl Pass {
visit_mut_pass(SafariIdDestructuringCollisionInFunctionExpression::default())
}
#[derive(Default, Clone)]
struct SafariIdDestructuringCollisionInFunctionExpression {
fn_expr_name: Atom,
destructured_id_span: Option<SyntaxContext>,
other_ident_symbols: FxHashSet<Atom>,
in_body: bool,
}
impl SafariIdDestructuringCollisionInFunctionExpression {
fn visit_mut_pat_id(&mut self, id: &Ident) {
if !self.in_body && self.fn_expr_name == id.sym {
self.destructured_id_span = Some(id.ctxt);
} else {
self.other_ident_symbols.insert(id.sym.clone());
}
}
}
#[swc_trace]
impl VisitMut for SafariIdDestructuringCollisionInFunctionExpression {
noop_visit_mut_type!(fail);
fn visit_mut_assign_pat_prop(&mut self, n: &mut AssignPatProp) {
self.visit_mut_pat_id(&Ident::from(&n.key));
n.value.visit_mut_with(self);
}
fn visit_mut_binding_ident(&mut self, binding_ident: &mut BindingIdent) {
self.visit_mut_pat_id(&Ident::from(&*binding_ident))
}
fn visit_mut_fn_expr(&mut self, n: &mut FnExpr) {
let old_in_body = self.in_body;
if let Some(ident) = &n.ident {
let old_span = self.destructured_id_span.take();
let old_fn_expr_name = self.fn_expr_name.clone();
self.fn_expr_name = ident.sym.clone();
self.in_body = false;
n.function.params.visit_mut_children_with(self);
self.in_body = true;
n.function.body.visit_mut_children_with(self);
if let Some(id_ctxt) = self.destructured_id_span.take() {
let mut rename_map = HashMap::default();
let new_id: Atom = {
let mut id_value: Atom = format!("_{}", self.fn_expr_name).into();
let mut count = 0;
while self.other_ident_symbols.contains(&id_value) {
count += 1;
id_value = format!("_{}{}", self.fn_expr_name, count).into();
}
id_value
};
let id = (self.fn_expr_name.clone(), id_ctxt);
rename_map.insert(id, new_id);
n.function.visit_mut_children_with(&mut rename(&rename_map));
}
self.fn_expr_name = old_fn_expr_name;
self.destructured_id_span = old_span;
} else {
self.in_body = false;
n.function.params.visit_mut_children_with(self);
self.in_body = true;
n.function.body.visit_mut_children_with(self);
}
self.in_body = old_in_body;
}
fn visit_mut_ident(&mut self, ident: &mut Ident) {
if self.in_body && self.fn_expr_name != ident.sym {
self.other_ident_symbols.insert(ident.sym.clone());
}
}
fn visit_mut_member_prop(&mut self, p: &mut MemberProp) {
if let MemberProp::Computed(..) = p {
p.visit_mut_children_with(self)
}
}
fn visit_mut_prop_name(&mut self, p: &mut PropName) {
if let PropName::Computed(..) = p {
p.visit_mut_children_with(self)
}
}
}
#[cfg(test)]
mod tests {
use swc_common::Mark;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_testing::{test, HygieneTester};
use swc_ecma_visit::fold_pass;
use super::*;
fn tr() -> impl Pass {
(
resolver(Mark::new(), Mark::new(), false),
safari_id_destructuring_collision_in_function_expression(),
)
}
test!(
Syntax::default(),
|_| tr(),
basic,
"(function a ([a]) { a });
(function a({ ...a }) { a });
(function a({ a }) { a });"
);
test!(
Syntax::default(),
|_| tr(),
avoid_collision_1,
"(function a([a, _a]) { a + _a })"
);
test!(
Syntax::default(),
|_| tr(),
use_duplicated_id,
"(function a([a]) { console.log(_a); })"
);
test!(
Syntax::default(),
|_| tr(),
avoid_collision_2,
"(function _a([_a]) { console.log(_a); })"
);
test!(
Syntax::default(),
|_| tr(),
assign_outside_var,
"let _a;
(function a([a]) {
_a = 3;
})"
);
test!(
Syntax::default(),
|_| tr(),
assignment_expr_in_default_value,
"(function a([a = a = 3]) {})"
);
test!(
Syntax::default(),
|_| (tr(), fold_pass(HygieneTester)),
issue_4488_1,
"
export default function _type_of() {
if (Date.now() > 0) {
_type_of = function _type_of() {
console.log(0);
};
} else {
_type_of = function _type_of() {
console.log(2);
};
}
return _type_of();
}
"
);
test!(
Syntax::default(),
|_| tr(),
in_nameless_fn,
"(function () {
(function a(a) {a});
});
"
);
test!(
Syntax::default(),
|_| tr(),
in_nameless_fn_multiple,
"// nameless iife
var x = function() {
// not transformed
var b = function a(a) {
return a;
};
}();
// nameless iife
var x = function x() {
var b = function a(_a) {
return _a;
};
}();
// nameless function
(function() {
// not transformed
var b = function a(a) {
return a;
};
});
// named function
(function x() {
var b = function a(_a) {
return _a;
};
});"
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/src/template_literal_caching.rs | Rust | use swc_common::DUMMY_SP;
use swc_ecma_ast::*;
use swc_ecma_utils::{prepend_stmt, private_ident, ExprFactory};
use swc_ecma_visit::{fold_pass, standard_only_fold, Fold, FoldWith};
use swc_trace_macro::swc_trace;
// Converts destructured parameters with default values to non-shorthand syntax.
// This fixes the only Tagged Templates-related bug in ES Modules-supporting
// browsers (Safari 10 & 11).
//
// Bug 1: Safari 10/11 doesn't reliably return the same Strings value.
// The value changes depending on invocation and function optimization state.
// function f() { return Object`` }
// f() === new f() // false, should be true.
//
// Bug 2: Safari 10/11 use the same cached strings value when the string parts
// are the same. This behavior comes from an earlier version of the spec, and
// can cause tricky bugs.
// Object``===Object`` // true, should be false.
//
// Benchmarks: https://jsperf.com/compiled-tagged-template-performance
pub fn template_literal_caching() -> impl Pass {
fold_pass(TemplateLiteralCaching::default())
}
#[derive(Default, Clone)]
struct TemplateLiteralCaching {
decls: Vec<VarDeclarator>,
helper_ident: Option<Ident>,
}
impl TemplateLiteralCaching {
fn create_binding(&mut self, name: Ident, init: Option<Expr>) {
let init = init.map(Box::new);
self.decls.push(VarDeclarator {
span: DUMMY_SP,
name: name.into(),
init,
definite: false,
})
}
fn create_var_decl(&mut self) -> Option<Stmt> {
if !self.decls.is_empty() {
return Some(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Let,
declare: false,
decls: self.decls.clone(),
..Default::default()
}
.into(),
);
}
None
}
}
/// TODO: VisitMut
#[swc_trace]
impl Fold for TemplateLiteralCaching {
standard_only_fold!();
fn fold_expr(&mut self, n: Expr) -> Expr {
let n = n.fold_children_with(self);
match n {
Expr::TaggedTpl(n) => {
if self.helper_ident.is_none() {
// Create an identity function helper:
// identity = t => t
let helper_ident = private_ident!("_");
let t = private_ident!("t");
self.helper_ident = Some(helper_ident.clone());
self.create_binding(
helper_ident,
Some(
ArrowExpr {
span: DUMMY_SP,
params: vec![t.clone().into()],
body: Box::new(BlockStmtOrExpr::Expr(t.into())),
is_async: false,
is_generator: false,
..Default::default()
}
.into(),
),
)
}
let helper_ident = self.helper_ident.as_ref().unwrap();
// Use the identity function helper to get a reference to the template's
// Strings. We replace all expressions with `0` ensure Strings has
// the same shape. identity`a${0}`
let template = TaggedTpl {
span: DUMMY_SP,
tag: helper_ident.clone().into(),
tpl: Box::new(Tpl {
span: DUMMY_SP,
quasis: n.tpl.quasis,
exprs: n.tpl.exprs.iter().map(|_| 0.0.into()).collect(),
}),
..Default::default()
};
// Install an inline cache at the callsite using the global variable:
// _t || (_t = identity`a${0}`)
let t = private_ident!("t");
self.create_binding(t.clone(), None);
let inline_cache: Expr = BinExpr {
span: DUMMY_SP,
op: op!("||"),
left: t.clone().into(),
right: AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: t.into(),
right: Box::new(Expr::TaggedTpl(template)),
}
.into(),
}
.into();
// The original tag function becomes a plain function call.
// The expressions omitted from the cached Strings tag are
// directly applied as arguments.
// tag(_t || (_t = Object`a${0}`), 'hello')
CallExpr {
span: DUMMY_SP,
callee: n.tag.as_callee(),
args: vec![inline_cache.as_arg()]
.into_iter()
.chain(n.tpl.exprs.into_iter().map(|expr| expr.as_arg()))
.collect(),
..Default::default()
}
.into()
}
_ => n,
}
}
fn fold_module(&mut self, n: Module) -> Module {
let mut body = n.body.fold_children_with(self);
if let Some(var) = self.create_var_decl() {
prepend_stmt(&mut body, var.into())
}
Module { body, ..n }
}
fn fold_script(&mut self, n: Script) -> Script {
let mut body = n.body.fold_children_with(self);
if let Some(var) = self.create_var_decl() {
prepend_stmt(&mut body, var)
}
Script { body, ..n }
}
}
#[cfg(test)]
mod tests {
use swc_common::Mark;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_testing::test;
use super::*;
fn tr() -> impl Pass {
(
resolver(Mark::new(), Mark::new(), false),
template_literal_caching(),
)
}
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
single_tag,
"t`a`;"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
single_tag_empty,
"x``;"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
multiple_tags,
r#"
t`a`;
x``;
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
function_scoped_tag,
"const f = t => t`a`;"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
dynamic_tag,
"fn()``;"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
dynamic_expressions,
"const f = t => t`a${1}b${t}${[\"hello\"]}`;"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
same_tag_safari_11,
"x`a` === x`a`;"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
shared_strings_safari_11,
"x`a` === y`a`;"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
template_literals,
r#"
`a`;
t(`a`);
t;
`a`;
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
prevent_tag_collision,
r#"
const _ = 1;
t``;
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
block_scoped_tag,
"for (let t of []) t`a`;"
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/async_arrows_in_class.rs/async_arrows.js | JavaScript | class Foo {
constructor(){
this.x = async function() {
return await 1;
};
}
bar() {
(async function() {})();
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/async_arrows_in_class.rs/callback.js | JavaScript | class Foo {
foo() {
bar(async function() {
return await 1;
});
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/async_arrows_in_class.rs/non_async_arrow.js | JavaScript | class Foo {
constructor(){
this.x = ()=>{};
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/async_arrows_in_class.rs/non_class_async_arrow.js | JavaScript | let x = async ()=>await 1;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/async_arrows_in_class.rs/this.js | JavaScript | class Foo {
constructor(){
var _this = this;
this.x = ()=>async function() {
return await _this;
};
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/edge_default_param.rs/destructured_default_value.js | JavaScript | const f = ({ a: a = 1 })=>a;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/edge_default_param.rs/destructured_no_default_value.js | JavaScript | const f = ({ a })=>a;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/edge_default_param.rs/nested_default_value.js | JavaScript | const f = ({ a: { b: b = 1 } })=>[
a,
b
];
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/edge_default_param.rs/non_arguments.js | JavaScript | const f = ()=>{
const { a = 1 } = {};
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/assign_outside_var.js | JavaScript | let _a;
(function a([_a1]) {
_a = 3;
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/assignment_expr_in_default_value.js | JavaScript | (function a([_a = _a = 3]) {});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/avoid_collision_1.js | JavaScript | (function a([_a1, _a]) {
_a1 + _a;
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/avoid_collision_2.js | JavaScript | (function _a([__a]) {
console.log(__a);
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/basic.js | JavaScript | (function a([_a]) {
_a;
});
(function a({ ..._a }) {
_a;
});
(function a({ a: _a }) {
_a;
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/in_nameless_fn.js | JavaScript | (function () {
(function a(_a) {
_a;
});
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/in_nameless_fn_multiple.js | JavaScript | // nameless iife
var x = function() {
// not transformed
var b = function a(_a) {
return _a;
};
}();
// nameless iife
var x = function x() {
var b = function a(_a) {
return _a;
};
}();
// nameless function
(function() {
// not transformed
var b = function a(_a1) {
return _a1;
};
});
// named function
(function x() {
var b = function a(_a) {
return _a;
};
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/issue_4488_1.js | JavaScript | export default function _type_of__2() {
if (Date__1.now() > 0) {
_type_of__2 = function _type_of__5() {
console__1.log(0);
};
} else {
_type_of__2 = function _type_of__8() {
console__1.log(2);
};
}
return _type_of__2();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/safari_id_destructuring_collision_in_function_expression.rs/use_duplicated_id.js | JavaScript | (function a([_a1]) {
console.log(_a);
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/block_scoped_tag.js | JavaScript | let _ = (t)=>t, t;
for (let t1 of [])t1(t || (t = _`a`));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/dynamic_expressions.js | JavaScript | let _ = (t)=>t, t;
const f = (t1)=>t1(t || (t = _`a${0}b${0}${0}`), 1, t1, [
"hello"
]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/dynamic_tag.js | JavaScript | let _ = (t)=>t, t;
fn()(t || (t = _``));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/function_scoped_tag.js | JavaScript | let _ = (t)=>t, t;
const f = (t1)=>t1(t || (t = _`a`));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/multiple_tags.js | JavaScript | let _ = (t1)=>t1, t1, t2;
t(t1 || (t1 = _`a`));
x(t2 || (t2 = _``));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/prevent_tag_collision.js | JavaScript | let _ = (t1)=>t1, t1;
const _1 = 1;
t(t1 || (t1 = _``));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/same_tag_safari_11.js | JavaScript | let _ = (t)=>t, t, t1;
x(t || (t = _`a`)) === x(t1 || (t1 = _`a`));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/shared_strings_safari_11.js | JavaScript | let _ = (t)=>t, t, t1;
x(t || (t = _`a`)) === y(t1 || (t1 = _`a`));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/single_tag.js | JavaScript | let _ = (t1)=>t1, t1;
t(t1 || (t1 = _`a`));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/single_tag_empty.js | JavaScript | let _ = (t)=>t, t;
x(t || (t = _``));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_bugfixes/tests/__swc_snapshots__/src/template_literal_caching.rs/template_literals.js | JavaScript | `a`;
t(`a`);
t;
`a`;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_common/src/lib.rs | Rust | pub mod macros;
pub mod regexp;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_common/src/macros.rs | Rust | /// Not a public API
#[macro_export]
macro_rules! impl_visit_mut_fn {
() => {
fn visit_mut_function(&mut self, f: &mut Function) {
if f.body.is_none() {
return;
}
f.visit_mut_children_with(self);
let (params, body) = self.visit_mut_fn_like(&mut f.params, &mut f.body.take().unwrap());
f.params = params;
f.body = Some(body);
}
fn visit_mut_arrow_expr(&mut self, f: &mut ArrowExpr) {
use swc_common::Spanned;
f.visit_mut_children_with(self);
let was_expr = match *f.body {
BlockStmtOrExpr::Expr(..) => true,
_ => false,
};
let (params, mut body) = self.visit_mut_fn_like(
&mut f
.params
.take()
.into_iter()
.map(|pat| Param {
span: DUMMY_SP,
decorators: Default::default(),
pat,
})
.collect(),
&mut match &mut *f.body {
BlockStmtOrExpr::BlockStmt(block) => block.take(),
BlockStmtOrExpr::Expr(expr) => BlockStmt {
stmts: vec![Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: Some(expr.take()),
})],
..Default::default()
},
},
);
let body = if was_expr
&& body.stmts.len() == 1
&& match body.stmts[0] {
Stmt::Return(ReturnStmt { arg: Some(..), .. }) => true,
_ => false,
} {
match body.stmts.pop().unwrap() {
Stmt::Return(ReturnStmt { arg: Some(arg), .. }) => {
Box::new(BlockStmtOrExpr::Expr(arg))
}
_ => unreachable!(),
}
} else {
Box::new(BlockStmtOrExpr::BlockStmt(body))
};
f.params = params.into_iter().map(|param| param.pat).collect();
f.body = body;
}
fn visit_mut_setter_prop(&mut self, f: &mut SetterProp) {
if f.body.is_none() {
return;
}
f.visit_mut_children_with(self);
let (mut params, body) = self.visit_mut_fn_like(
&mut vec![Param {
span: DUMMY_SP,
decorators: Vec::new(),
pat: *f.param.take(),
}],
&mut f.body.take().unwrap(),
);
debug_assert!(params.len() == 1);
f.param = Box::new(params.into_iter().next().unwrap().pat);
f.body = Some(body);
}
fn visit_mut_getter_prop(&mut self, f: &mut GetterProp) {
if f.body.is_none() {
return;
}
f.visit_mut_children_with(self);
let (params, body) =
self.visit_mut_fn_like(&mut Vec::new(), &mut f.body.take().unwrap());
debug_assert_eq!(params, Vec::new());
f.body = Some(body);
}
fn visit_mut_catch_clause(&mut self, f: &mut CatchClause) {
f.visit_mut_children_with(self);
let (mut params, body) = match &mut f.param {
Some(pat) => self.visit_mut_fn_like(
&mut vec![Param {
span: DUMMY_SP,
decorators: Vec::new(),
pat: pat.take(),
}],
&mut f.body.take(),
),
None => self.visit_mut_fn_like(&mut Vec::new(), &mut f.body.take()),
};
assert!(
params.len() == 0 || params.len() == 1,
"fold_fn_like should return 0 ~ 1 parameter while handling catch clause"
);
let param = if params.is_empty() {
None
} else {
Some(params.pop().unwrap())
};
f.param = param.map(|param| param.pat);
f.body = body;
}
fn visit_mut_constructor(&mut self, f: &mut Constructor) {
if f.body.is_none() {
return;
}
tracing::trace!("visit_mut_constructor(parmas.len() = {})", f.params.len());
f.visit_mut_children_with(self);
let mut params = f
.params
.take()
.into_iter()
.map(|pat| match pat {
ParamOrTsParamProp::Param(p) => p,
_ => unreachable!(
"TsParameterProperty should be removed by typescript::strip pass"
),
})
.collect();
let (params, body) = self.visit_mut_fn_like(&mut params, &mut f.body.take().unwrap());
tracing::trace!(
"visit_mut_constructor(parmas.len() = {}, after)",
params.len()
);
f.params = params.into_iter().map(ParamOrTsParamProp::Param).collect();
f.body = Some(body);
}
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_common/src/regexp.rs | Rust | use swc_common::util::take::Take;
use swc_ecma_ast::{CallExpr, Expr, Lit, Pass, Regex};
use swc_ecma_utils::{quote_ident, ExprFactory};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
pub fn regexp(config: Config) -> impl Pass {
visit_mut_pass(RegExp { config })
}
#[derive(Default, Clone, Copy)]
pub struct Config {
/// [s/dotAll flag for regular expressions](https://tc39.github.io/proposal-regexp-dotall-flag/)
pub dot_all_regex: bool,
/// [RegExp.prototype.hasIndices](https://262.ecma-international.org/13.0/#sec-get-regexp.prototype.hasIndices)
pub has_indices: bool,
/// [RegExp Lookbehind Assertions](https://tc39.es/proposal-regexp-lookbehind/)
pub lookbehind_assertion: bool,
/// [Named capture groups in regular expressions](https://tc39.es/proposal-regexp-named-groups/)
pub named_capturing_groups_regex: bool,
/// [RegExp.prototype.sticky](https://tc39.es/ecma262/multipage/text-processing.html#sec-get-regexp.prototype.sticky)
pub sticky_regex: bool,
/// [Unicode property escapes in regular expressions](https://tc39.es/proposal-regexp-unicode-property-escapes/)
pub unicode_property_regex: bool,
/// [RegExp.prototype.unicode](https://tc39.es/ecma262/multipage/text-processing.html#sec-get-regexp.prototype.unicode)
pub unicode_regex: bool,
// [RegExp.prototype.unicodeSets](https://github.com/tc39/proposal-regexp-v-flag)
pub unicode_sets_regex: bool,
}
struct RegExp {
config: Config,
}
impl VisitMut for RegExp {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Expr::Lit(Lit::Regex(regex)) = expr {
if (self.config.dot_all_regex && regex.flags.contains('s'))
|| (self.config.sticky_regex && regex.flags.contains('y'))
|| (self.config.unicode_regex && regex.flags.contains('u'))
|| (self.config.unicode_sets_regex && regex.flags.contains('v'))
|| (self.config.has_indices && regex.flags.contains('d'))
|| (self.config.named_capturing_groups_regex && regex.exp.contains("(?<"))
|| (self.config.lookbehind_assertion && regex.exp.contains("(?<=")
|| regex.exp.contains("(?<!"))
|| (self.config.unicode_property_regex
&& (regex.exp.contains("\\p{") || regex.exp.contains("\\P{")))
{
let Regex { exp, flags, span } = regex.take();
let exp: Expr = exp.into();
let mut args = vec![exp.into()];
if !flags.is_empty() {
let flags: Expr = flags.into();
args.push(flags.into());
}
*expr = CallExpr {
span,
callee: quote_ident!("RegExp").as_callee(),
args,
..Default::default()
}
.into()
}
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/arrow.rs | Rust | use std::mem;
use swc_common::{util::take::Take, Mark, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_utils::{
function::{init_this, FnEnvHoister},
prepend_stmt,
};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, InjectVars, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
/// Compile ES2015 arrow functions to ES5
///
///# Example
///
///## In
/// ```js
/// var a = () => {};
/// var a = (b) => b;ß
///
/// const double = [1,2,3].map((num) => num * 2);
/// console.log(double); // [2,4,6]
///
/// var bob = {
/// _name: "Bob",
/// _friends: ["Sally", "Tom"],
/// printFriends() {
/// this._friends.forEach(f =>
/// console.log(this._name + " knows " + f));
/// }
/// };
/// console.log(bob.printFriends());
/// ```
///
///## Out
///```js
/// var a = function () {};
/// var a = function (b) {
/// return b;
/// };
///
/// const double = [1, 2, 3].map(function (num) {
/// return num * 2;
/// });
/// console.log(double); // [2,4,6]
///
/// var bob = {
/// _name: "Bob",
/// _friends: ["Sally", "Tom"],
/// printFriends() {
/// var _this = this;
///
/// this._friends.forEach(function (f) {
/// return console.log(_this._name + " knows " + f);
/// });
/// }
/// };
/// console.log(bob.printFriends());
/// ```
pub fn arrow(unresolved_mark: Mark) -> impl Pass + VisitMut + InjectVars {
visit_mut_pass(Arrow {
in_subclass: false,
hoister: FnEnvHoister::new(SyntaxContext::empty().apply_mark(unresolved_mark)),
})
}
#[derive(Default)]
struct Arrow {
in_subclass: bool,
hoister: FnEnvHoister,
}
#[swc_trace]
impl VisitMut for Arrow {
noop_visit_mut_type!(fail);
fn visit_mut_class(&mut self, c: &mut Class) {
let old = self.in_subclass;
if c.super_class.is_some() {
self.in_subclass = true;
}
c.visit_mut_children_with(self);
self.in_subclass = old;
}
fn visit_mut_constructor(&mut self, c: &mut Constructor) {
c.params.visit_mut_children_with(self);
if let Some(BlockStmt { span: _, stmts, .. }) = &mut c.body {
let old_rep = self.hoister.take();
stmts.visit_mut_children_with(self);
if self.in_subclass {
let (decl, this_id) =
mem::replace(&mut self.hoister, old_rep).to_stmt_in_subclass();
if let Some(stmt) = decl {
if let Some(this_id) = this_id {
init_this(stmts, &this_id)
}
prepend_stmt(stmts, stmt);
}
} else {
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(stmt) = decl {
prepend_stmt(stmts, stmt);
}
}
}
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
match expr {
Expr::Arrow(ArrowExpr {
span,
params,
body,
is_async,
is_generator,
..
}) => {
params.visit_mut_with(self);
params.visit_mut_with(&mut self.hoister);
let params: Vec<Param> = params
.take()
.into_iter()
.map(|pat| Param {
span: DUMMY_SP,
decorators: Default::default(),
pat,
})
.collect();
body.visit_mut_with(self);
body.visit_mut_with(&mut self.hoister);
let fn_expr = Function {
decorators: Vec::new(),
span: *span,
params,
is_async: *is_async,
is_generator: *is_generator,
body: Some(match &mut **body {
BlockStmtOrExpr::BlockStmt(block) => block.take(),
BlockStmtOrExpr::Expr(expr) => BlockStmt {
span: DUMMY_SP,
stmts: vec![Stmt::Return(ReturnStmt {
// this is needed so
// () => /* 123 */ 1 would become
// function { return /*123 */ 123 }
span: DUMMY_SP,
arg: Some(expr.take()),
})],
..Default::default()
},
}),
..Default::default()
}
.into();
*expr = fn_expr;
}
_ => {
expr.visit_mut_children_with(self);
}
}
}
fn visit_mut_function(&mut self, f: &mut Function) {
let old_rep = self.hoister.take();
f.visit_mut_children_with(self);
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let (Some(body), Some(stmt)) = (&mut f.body, decl) {
prepend_stmt(&mut body.stmts, stmt);
}
}
fn visit_mut_getter_prop(&mut self, f: &mut GetterProp) {
f.key.visit_mut_with(self);
if let Some(body) = &mut f.body {
let old_rep = self.hoister.take();
body.visit_mut_with(self);
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(stmt) = decl {
prepend_stmt(&mut body.stmts, stmt);
}
}
}
fn visit_mut_module_items(&mut self, stmts: &mut Vec<ModuleItem>) {
stmts.visit_mut_children_with(self);
let decl = self.hoister.take().to_stmt();
if let Some(stmt) = decl {
prepend_stmt(stmts, stmt.into());
}
}
fn visit_mut_script(&mut self, script: &mut Script) {
script.visit_mut_children_with(self);
let decl = self.hoister.take().to_stmt();
if let Some(stmt) = decl {
prepend_stmt(&mut script.body, stmt);
}
}
fn visit_mut_setter_prop(&mut self, f: &mut SetterProp) {
f.key.visit_mut_with(self);
f.param.visit_mut_with(self);
if let Some(body) = &mut f.body {
let old_rep = self.hoister.take();
body.visit_mut_with(self);
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(stmt) = decl {
prepend_stmt(&mut body.stmts, stmt);
}
}
}
}
impl InjectVars for Arrow {
fn take_vars(&mut self) -> Vec<VarDeclarator> {
self.hoister.take().to_decl()
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/block_scoped_fn.rs | Rust | use swc_common::{util::take::Take, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_utils::IdentUsageFinder;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
pub fn block_scoped_functions() -> impl Pass {
visit_mut_pass(BlockScopedFns)
}
#[derive(Clone, Copy)]
struct BlockScopedFns;
#[swc_trace]
impl VisitMut for BlockScopedFns {
noop_visit_mut_type!(fail);
fn visit_mut_function(&mut self, n: &mut Function) {
let Some(body) = &mut n.body else { return };
n.params.visit_mut_with(self);
// skip function scope
body.visit_mut_children_with(self);
}
fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt) {
n.visit_mut_children_with(self);
let mut stmts = Vec::with_capacity(n.stmts.len());
let mut extra_stmts = Vec::with_capacity(n.stmts.len());
for stmt in n.stmts.take() {
if let Stmt::Expr(ExprStmt { ref expr, .. }) = stmt {
if let Expr::Lit(Lit::Str(..)) = &**expr {
stmts.push(stmt);
continue;
}
}
if let Stmt::Decl(Decl::Fn(decl)) = stmt {
if IdentUsageFinder::find(&decl.ident.to_id(), &decl.function) {
extra_stmts.push(decl.into());
continue;
}
stmts.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Let,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: decl.ident.clone().into(),
init: Some(Box::new(Expr::Fn(FnExpr {
ident: Some(decl.ident),
function: decl.function,
}))),
definite: false,
}],
..Default::default()
}
.into(),
)
} else {
extra_stmts.push(stmt)
}
}
stmts.append(&mut extra_stmts);
n.stmts = stmts
}
}
#[cfg(test)]
mod tests {
use swc_ecma_transforms_testing::test;
use super::*;
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoped_functions(),
hoisting,
r#"
{
function fn1() { fn2(); }
fn1();
function fn2() { }
}
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoped_functions(),
basic,
r#"{
function name (n) {
return n;
}
}
name("Steve");"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoped_functions(),
basic_2,
r#"
{
function foo() {
return function bar() {
{
function baz() {}
}
};
function baz() {}
{
function bar() {}
{
function bar() {}
}
}
}
}
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoped_functions(),
issue_271,
"
function foo(scope) {
scope.startOperation = startOperation;
function startOperation(operation) {
scope.agentOperation = operation;
}
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoped_functions(),
issue_288_1,
"function components_Link_extends() { components_Link_extends = Object.assign || function \
(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for \
(var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { \
target[key] = source[key]; } } } return target; }; return \
components_Link_extends.apply(this, arguments); }
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoped_functions(),
issue_288_2,
"function _extends() {
module.exports = _extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoped_functions(),
hoisting_directives,
"function foo() {
'use strict';
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
}"
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/block_scoping/mod.rs | Rust | use std::{iter::once, mem::take};
use indexmap::IndexMap;
use rustc_hash::{FxHashMap, FxHashSet};
use smallvec::SmallVec;
use swc_atoms::Atom;
use swc_common::{util::take::Take, Mark, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::helper;
use swc_ecma_utils::{
find_pat_ids, function::FnEnvHoister, prepend_stmt, private_ident, quote_ident, quote_str,
ExprFactory, StmtLike,
};
use swc_ecma_visit::{
noop_visit_mut_type, visit_mut_obj_and_computed, visit_mut_pass, VisitMut, VisitMutWith,
};
use swc_trace_macro::swc_trace;
mod vars;
///
///
/// TODO(kdy1): Optimization
///
/// ```js
/// let functions = [];
/// for (let i = 0; i < 10; i++) {
/// functions.push(function() {
/// let i = 1;
/// console.log(i);
/// });
/// }
/// ```
pub fn block_scoping(unresolved_mark: Mark) -> impl Pass {
(
visit_mut_pass(self::vars::block_scoped_vars()),
visit_mut_pass(BlockScoping {
unresolved_mark,
scope: Default::default(),
vars: Vec::new(),
var_decl_kind: VarDeclKind::Var,
}),
)
}
type ScopeStack = SmallVec<[ScopeKind; 8]>;
#[derive(Debug, PartialEq, Eq)]
enum ScopeKind {
Loop {
lexical_var: Vec<Id>,
args: Vec<Id>,
/// Produced by identifier reference and consumed by for-of/in loop.
used: Vec<Id>,
/// Map of original identifier to modified syntax context
mutated: FxHashMap<Id, SyntaxContext>,
},
Fn,
Block,
}
impl ScopeKind {
fn new_loop() -> Self {
ScopeKind::Loop {
lexical_var: Vec::new(),
args: Vec::new(),
used: Vec::new(),
mutated: Default::default(),
}
}
}
struct BlockScoping {
unresolved_mark: Mark,
scope: ScopeStack,
vars: Vec<VarDeclarator>,
var_decl_kind: VarDeclKind,
}
impl BlockScoping {
/// This methods remove [ScopeKind::Loop] and [ScopeKind::Fn], but not
/// [ScopeKind::ForLetLoop]
fn visit_mut_with_scope<T>(&mut self, kind: ScopeKind, node: &mut T)
where
T: VisitMutWith<Self>,
{
let remove = !matches!(kind, ScopeKind::Loop { .. });
self.scope.push(kind);
node.visit_mut_with(self);
if remove {
self.scope.pop();
}
}
fn mark_as_used(&mut self, i: Id) {
// Only consider the variable used in a non-ScopeKind::Loop, which means it is
// captured in a closure
for scope in self
.scope
.iter_mut()
.rev()
.skip_while(|scope| matches!(scope, ScopeKind::Loop { .. }))
{
if let ScopeKind::Loop {
lexical_var, used, ..
} = scope
{
if lexical_var.contains(&i) {
used.push(i);
return;
}
}
}
}
fn in_loop_body(&self) -> bool {
self.scope
.last()
.map(|scope| matches!(scope, ScopeKind::Loop { .. }))
.unwrap_or(false)
}
fn handle_capture_of_vars(&mut self, body: &mut Box<Stmt>) {
let body_stmt = &mut **body;
if let Some(ScopeKind::Loop {
args,
used,
mutated,
..
}) = self.scope.pop()
{
if used.is_empty() {
return;
}
let mut env_hoister =
FnEnvHoister::new(SyntaxContext::empty().apply_mark(self.unresolved_mark));
body_stmt.visit_mut_with(&mut env_hoister);
let mut inits: Vec<Box<Expr>> = Vec::new();
for mut var in env_hoister.to_decl() {
if let Some(init) = var.init.take() {
inits.push(
AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: var.name.clone().try_into().unwrap(),
right: init,
}
.into(),
);
}
self.vars.push(var);
}
let mut flow_helper = FlowHelper {
all: &args,
has_break: false,
has_return: false,
has_yield: false,
has_await: false,
label: IndexMap::new(),
inner_label: FxHashSet::default(),
mutated,
in_switch_case: false,
in_nested_loop: false,
};
body_stmt.visit_mut_with(&mut flow_helper);
let mut body_stmt = match &mut body_stmt.take() {
Stmt::Block(bs) => bs.take(),
body => BlockStmt {
span: DUMMY_SP,
stmts: vec![body.take()],
..Default::default()
},
};
if !flow_helper.mutated.is_empty() {
let no_modification = flow_helper.mutated.is_empty();
let mut v = MutationHandler {
map: &mut flow_helper.mutated,
in_function: false,
};
// Modifies identifiers, and add reassignments to break / continue / return
body_stmt.visit_mut_with(&mut v);
if !no_modification
&& body_stmt
.stmts
.last()
.map(|s| !matches!(s, Stmt::Return(..)))
.unwrap_or(true)
{
body_stmt.stmts.push(v.make_reassignment(None).into_stmt());
}
}
let var_name = private_ident!("_loop");
self.vars.push(VarDeclarator {
span: DUMMY_SP,
name: var_name.clone().into(),
init: Some(
Function {
span: DUMMY_SP,
params: args
.iter()
.map(|i| {
let ctxt = flow_helper.mutated.get(i).copied().unwrap_or(i.1);
Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: Ident::new(i.0.clone(), DUMMY_SP, ctxt).into(),
}
})
.collect(),
decorators: Default::default(),
body: Some(body_stmt),
is_generator: flow_helper.has_yield,
is_async: flow_helper.has_await,
..Default::default()
}
.into(),
),
definite: false,
});
let mut call: Expr = CallExpr {
span: DUMMY_SP,
callee: var_name.as_callee(),
args: args
.iter()
.cloned()
.map(|i| Ident::new(i.0, DUMMY_SP, i.1).as_arg())
.collect(),
..Default::default()
}
.into();
if flow_helper.has_await {
call = AwaitExpr {
span: DUMMY_SP,
arg: call.into(),
}
.into();
}
if flow_helper.has_yield {
call = YieldExpr {
span: DUMMY_SP,
arg: Some(call.into()),
delegate: true,
}
.into();
}
if !inits.is_empty() {
call = SeqExpr {
span: DUMMY_SP,
exprs: inits.into_iter().chain(once(Box::new(call))).collect(),
}
.into()
}
if flow_helper.has_return || flow_helper.has_break || !flow_helper.label.is_empty() {
let ret = private_ident!("_ret");
let mut stmts = vec![
// var _ret = _loop(i);
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: ret.clone().into(),
init: Some(Box::new(call.take())),
definite: false,
}],
..Default::default()
}
.into(),
];
if flow_helper.has_return {
// if (_type_of(_ret) === "object") return _ret.v;
stmts.push(
IfStmt {
span: DUMMY_SP,
test: BinExpr {
span: DUMMY_SP,
op: op!("==="),
left: {
// _type_of(_ret)
let callee = helper!(type_of);
CallExpr {
span: Default::default(),
callee,
args: vec![ret.clone().as_arg()],
..Default::default()
}
.into()
},
//"object"
right: "object".into(),
}
.into(),
cons: Box::new(
ReturnStmt {
span: DUMMY_SP,
arg: Some(ret.clone().make_member(quote_ident!("v")).into()),
}
.into(),
),
alt: None,
}
.into(),
)
}
if flow_helper.has_break {
stmts.push(
IfStmt {
span: DUMMY_SP,
test: ret.clone().make_eq(quote_str!("break")).into(),
cons: BreakStmt {
span: DUMMY_SP,
label: None,
}
.into(),
alt: None,
}
.into(),
);
}
if !flow_helper.label.is_empty() {
stmts.push(
SwitchStmt {
span: DUMMY_SP,
discriminant: Box::new(ret.into()),
cases: flow_helper
.label
.into_iter()
.map(|(key, label)| SwitchCase {
span: DUMMY_SP,
test: Some(Box::new(key.into())),
cons: vec![match label {
Label::Break(id) => Stmt::Break(BreakStmt {
span: DUMMY_SP,
label: Some(id),
}),
Label::Continue(id) => Stmt::Continue(ContinueStmt {
span: DUMMY_SP,
label: Some(id),
}),
}],
})
.collect(),
}
.into(),
);
}
*body = Box::new(
BlockStmt {
span: DUMMY_SP,
stmts,
..Default::default()
}
.into(),
);
return;
}
*body = Box::new(call.take().into_stmt());
}
}
/// This method will turn stmt like
/// ```js
/// for (let i in [1, 2])
/// for (let j in [1, 2])
/// console.log(i, j)
/// ```
/// into
/// ```js
/// for (let i in [1, 2]) {
/// for (let j in [1, 2]) {
/// console.log(i, j)
/// }
/// }
/// ```
/// which fixes https://github.com/swc-project/swc/issues/6573
fn blockify_for_stmt_body(&self, body: &mut Box<Stmt>) -> bool {
if !body.is_block() {
*body = Box::new(
BlockStmt {
span: Default::default(),
stmts: vec![*body.take()],
..Default::default()
}
.into(),
);
true
} else {
false
}
}
fn undo_blockify_for_stmt_body(&self, body: &mut Box<Stmt>, blockifyed: bool) {
if blockifyed {
let stmt = body
.as_mut_block()
.and_then(|block| (block.stmts.len() == 1).then(|| block.stmts[0].take()));
if let Some(stmt) = stmt {
*body = Box::new(stmt)
}
}
}
}
#[swc_trace]
impl VisitMut for BlockScoping {
noop_visit_mut_type!(fail);
fn visit_mut_arrow_expr(&mut self, n: &mut ArrowExpr) {
n.params.visit_mut_with(self);
self.visit_mut_with_scope(ScopeKind::Fn, &mut n.body);
}
fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt) {
let vars = take(&mut self.vars);
n.visit_mut_children_with(self);
debug_assert_eq!(self.vars, Vec::new());
self.vars = vars;
}
fn visit_mut_constructor(&mut self, f: &mut Constructor) {
f.key.visit_mut_with(self);
f.params.visit_mut_with(self);
self.visit_mut_with_scope(ScopeKind::Fn, &mut f.body);
}
fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
self.visit_mut_with_scope(ScopeKind::new_loop(), &mut node.body);
node.test.visit_mut_with(self);
self.handle_capture_of_vars(&mut node.body);
}
fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
let blockifyed = self.blockify_for_stmt_body(&mut node.body);
let lexical_var = if let ForHead::VarDecl(decl) = &node.left {
find_lexical_vars(decl)
} else {
Vec::new()
};
let args = lexical_var.clone();
self.visit_mut_with_scope(ScopeKind::Block, &mut node.left);
node.right.visit_mut_with(self);
let kind = ScopeKind::Loop {
lexical_var,
args,
used: Vec::new(),
mutated: Default::default(),
};
self.visit_mut_with_scope(kind, &mut node.body);
self.handle_capture_of_vars(&mut node.body);
self.undo_blockify_for_stmt_body(&mut node.body, blockifyed);
}
fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
let blockifyed = self.blockify_for_stmt_body(&mut node.body);
let vars = if let ForHead::VarDecl(decl) = &node.left {
find_lexical_vars(decl)
} else {
Vec::new()
};
self.visit_mut_with_scope(ScopeKind::Block, &mut node.left);
let args = vars.clone();
node.right.visit_mut_with(self);
let kind = ScopeKind::Loop {
lexical_var: vars,
args,
used: Vec::new(),
mutated: Default::default(),
};
self.visit_mut_with_scope(kind, &mut node.body);
self.handle_capture_of_vars(&mut node.body);
self.undo_blockify_for_stmt_body(&mut node.body, blockifyed);
}
fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
let blockifyed = self.blockify_for_stmt_body(&mut node.body);
let lexical_var = if let Some(VarDeclOrExpr::VarDecl(decl)) = &node.init {
find_lexical_vars(decl)
} else {
Vec::new()
};
node.init.visit_mut_with(self);
let args = lexical_var.clone();
node.test.visit_mut_with(self);
node.update.visit_mut_with(self);
let kind = ScopeKind::Loop {
lexical_var,
args,
used: Vec::new(),
mutated: Default::default(),
};
self.visit_mut_with_scope(kind, &mut node.body);
self.handle_capture_of_vars(&mut node.body);
self.undo_blockify_for_stmt_body(&mut node.body, blockifyed);
}
fn visit_mut_function(&mut self, f: &mut Function) {
f.params.visit_mut_with(self);
f.decorators.visit_mut_with(self);
self.visit_mut_with_scope(ScopeKind::Fn, &mut f.body);
}
fn visit_mut_getter_prop(&mut self, f: &mut GetterProp) {
f.key.visit_mut_with(self);
self.visit_mut_with_scope(ScopeKind::Fn, &mut f.body);
}
fn visit_mut_ident(&mut self, node: &mut Ident) {
let id = node.to_id();
self.mark_as_used(id);
}
fn visit_mut_module_items(&mut self, stmts: &mut Vec<ModuleItem>) {
self.visit_mut_stmt_like(stmts);
}
fn visit_mut_setter_prop(&mut self, f: &mut SetterProp) {
f.key.visit_mut_with(self);
f.param.visit_mut_with(self);
self.visit_mut_with_scope(ScopeKind::Fn, &mut f.body);
}
fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt>) {
self.visit_mut_stmt_like(n);
}
fn visit_mut_switch_case(&mut self, n: &mut SwitchCase) {
let old_vars = self.vars.take();
n.visit_mut_children_with(self);
self.vars = old_vars;
}
fn visit_mut_var_decl(&mut self, var: &mut VarDecl) {
let old = self.var_decl_kind;
self.var_decl_kind = var.kind;
if let Some(ScopeKind::Loop { lexical_var, .. }) = self.scope.last_mut() {
lexical_var.extend(find_lexical_vars(var));
}
var.visit_mut_children_with(self);
self.var_decl_kind = old;
var.kind = VarDeclKind::Var;
}
fn visit_mut_var_declarator(&mut self, var: &mut VarDeclarator) {
var.visit_mut_children_with(self);
if self.in_loop_body() && var.init.is_none() {
if self.var_decl_kind == VarDeclKind::Var {
var.init = None
} else {
var.init = Some(Expr::undefined(var.span()))
}
}
}
fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
self.visit_mut_with_scope(ScopeKind::new_loop(), &mut node.body);
node.test.visit_mut_with(self);
self.handle_capture_of_vars(&mut node.body);
}
}
impl BlockScoping {
fn visit_mut_stmt_like<T>(&mut self, stmts: &mut Vec<T>)
where
T: StmtLike,
Vec<T>: VisitMutWith<Self>,
{
stmts.visit_mut_children_with(self);
if !self.vars.is_empty() {
prepend_stmt(
stmts,
T::from(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: false,
decls: take(&mut self.vars),
..Default::default()
}
.into(),
),
);
}
}
}
fn find_lexical_vars(node: &VarDecl) -> Vec<Id> {
if node.kind == VarDeclKind::Var {
return Vec::new();
}
find_pat_ids(&node.decls)
}
struct FlowHelper<'a> {
has_break: bool,
has_return: bool,
has_yield: bool,
has_await: bool,
// label cannot be shadowed, so it's pretty safe to use Atom
label: IndexMap<Atom, Label>,
inner_label: FxHashSet<Atom>,
all: &'a Vec<Id>,
mutated: FxHashMap<Id, SyntaxContext>,
in_switch_case: bool,
in_nested_loop: bool,
}
enum Label {
Break(Ident),
Continue(Ident),
}
impl FlowHelper<'_> {
fn check(&mut self, i: Id) {
if self.all.contains(&i) {
self.mutated.insert(
i,
SyntaxContext::empty().apply_mark(Mark::fresh(Mark::root())),
);
}
}
fn has_outer_label(&self, label: &Option<Ident>) -> bool {
match label {
Some(l) => !self.inner_label.contains(&l.sym),
None => false,
}
}
}
#[swc_trace]
impl VisitMut for FlowHelper<'_> {
noop_visit_mut_type!(fail);
/// noop
fn visit_mut_arrow_expr(&mut self, _n: &mut ArrowExpr) {}
fn visit_mut_assign_expr(&mut self, n: &mut AssignExpr) {
match &n.left {
AssignTarget::Simple(e) => {
if let SimpleAssignTarget::Ident(i) = e {
self.check(i.to_id());
}
}
AssignTarget::Pat(p) => {
let ids: Vec<Id> = find_pat_ids(p);
for id in ids {
self.check(id);
}
}
}
n.visit_mut_children_with(self);
}
fn visit_mut_await_expr(&mut self, e: &mut AwaitExpr) {
e.visit_mut_children_with(self);
self.has_await = true;
}
/// https://github.com/swc-project/swc/pull/2916
fn visit_mut_do_while_stmt(&mut self, s: &mut DoWhileStmt) {
let old = self.in_nested_loop;
self.in_nested_loop = true;
s.visit_mut_children_with(self);
self.in_nested_loop = old;
}
/// https://github.com/swc-project/swc/pull/2916
fn visit_mut_for_in_stmt(&mut self, s: &mut ForInStmt) {
let old = self.in_nested_loop;
self.in_nested_loop = true;
s.visit_mut_children_with(self);
self.in_nested_loop = old;
}
/// https://github.com/swc-project/swc/pull/2916
fn visit_mut_for_of_stmt(&mut self, s: &mut ForOfStmt) {
let old = self.in_nested_loop;
self.in_nested_loop = true;
s.visit_mut_children_with(self);
self.in_nested_loop = old;
}
/// https://github.com/swc-project/swc/pull/2916
fn visit_mut_for_stmt(&mut self, s: &mut ForStmt) {
let old = self.in_nested_loop;
self.in_nested_loop = true;
s.visit_mut_children_with(self);
self.in_nested_loop = old;
}
/// noop
fn visit_mut_function(&mut self, _f: &mut Function) {}
/// noop
fn visit_mut_getter_prop(&mut self, _f: &mut GetterProp) {}
/// noop
fn visit_mut_setter_prop(&mut self, _f: &mut SetterProp) {}
fn visit_mut_labeled_stmt(&mut self, l: &mut LabeledStmt) {
self.inner_label.insert(l.label.sym.clone());
l.visit_mut_children_with(self);
}
fn visit_mut_stmt(&mut self, node: &mut Stmt) {
let span = node.span();
match node {
Stmt::Continue(ContinueStmt { label, .. }) => {
if self.in_nested_loop && !self.has_outer_label(label) {
return;
}
let value = if let Some(label) = label {
let value: Atom = format!("continue|{}", label.sym).into();
self.label
.insert(value.clone(), Label::Continue(label.clone()));
value
} else {
"continue".into()
};
*node = ReturnStmt {
span,
arg: Some(
Lit::Str(Str {
span,
value,
raw: None,
})
.into(),
),
}
.into();
}
Stmt::Break(BreakStmt { label, .. }) => {
if (self.in_switch_case || self.in_nested_loop) && !self.has_outer_label(label) {
return;
}
let value = if let Some(label) = label {
let value: Atom = format!("break|{}", label.sym).into();
self.label
.insert(value.clone(), Label::Break(label.clone()));
value
} else {
self.has_break = true;
"break".into()
};
*node = ReturnStmt {
span,
arg: Some(
Lit::Str(Str {
span,
value,
raw: None,
})
.into(),
),
}
.into();
}
Stmt::Return(s) => {
self.has_return = true;
s.visit_mut_with(self);
*node = ReturnStmt {
span,
arg: Some(
ObjectLit {
span,
props: vec![PropOrSpread::Prop(Box::new(Prop::KeyValue(
KeyValueProp {
key: PropName::Ident(IdentName::new("v".into(), DUMMY_SP)),
value: s.arg.take().unwrap_or_else(|| {
Box::new(Expr::Unary(UnaryExpr {
span: DUMMY_SP,
op: op!("void"),
arg: Expr::undefined(DUMMY_SP),
}))
}),
},
)))],
}
.into(),
),
}
.into();
}
_ => node.visit_mut_children_with(self),
}
}
fn visit_mut_switch_case(&mut self, n: &mut SwitchCase) {
let old = self.in_switch_case;
self.in_switch_case = true;
n.visit_mut_children_with(self);
self.in_switch_case = old;
}
fn visit_mut_update_expr(&mut self, n: &mut UpdateExpr) {
if let Expr::Ident(ref i) = *n.arg {
self.check(i.to_id())
}
n.visit_mut_children_with(self);
}
/// https://github.com/swc-project/swc/pull/2916
fn visit_mut_while_stmt(&mut self, s: &mut WhileStmt) {
let old = self.in_nested_loop;
self.in_nested_loop = true;
s.visit_mut_children_with(self);
self.in_nested_loop = old;
}
fn visit_mut_yield_expr(&mut self, e: &mut YieldExpr) {
e.visit_mut_children_with(self);
self.has_yield = true;
}
}
struct MutationHandler<'a> {
map: &'a mut FxHashMap<Id, SyntaxContext>,
in_function: bool,
}
impl MutationHandler<'_> {
fn make_reassignment(&self, orig: Option<Box<Expr>>) -> Expr {
if self.map.is_empty() {
return *orig.unwrap_or_else(|| Expr::undefined(DUMMY_SP));
}
let mut exprs = Vec::with_capacity(self.map.len() + 1);
for (id, ctxt) in &*self.map {
exprs.push(
AssignExpr {
span: DUMMY_SP,
left: Ident::new(id.0.clone(), DUMMY_SP, id.1).into(),
op: op!("="),
right: Box::new(Ident::new(id.0.clone(), DUMMY_SP, *ctxt).into()),
}
.into(),
);
}
exprs.push(orig.unwrap_or_else(|| Expr::undefined(DUMMY_SP)));
SeqExpr {
span: DUMMY_SP,
exprs,
}
.into()
}
}
#[swc_trace]
impl VisitMut for MutationHandler<'_> {
noop_visit_mut_type!(fail);
visit_mut_obj_and_computed!();
fn visit_mut_arrow_expr(&mut self, n: &mut ArrowExpr) {
let old = self.in_function;
self.in_function = true;
n.visit_mut_children_with(self);
self.in_function = old;
}
fn visit_mut_function(&mut self, n: &mut Function) {
let old = self.in_function;
self.in_function = true;
n.visit_mut_children_with(self);
self.in_function = old;
}
fn visit_mut_ident(&mut self, n: &mut Ident) {
if let Some(&ctxt) = self.map.get(&n.to_id()) {
n.ctxt = ctxt;
}
}
fn visit_mut_return_stmt(&mut self, n: &mut ReturnStmt) {
n.visit_mut_children_with(self);
if self.in_function || self.map.is_empty() {
return;
}
let val = n.arg.take();
n.arg = Some(Box::new(self.make_reassignment(val)))
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/block_scoping/vars.rs | Rust | use indexmap::IndexMap;
use rustc_hash::{FxBuildHasher, FxHashMap};
use swc_atoms::Atom;
use swc_common::{Mark, SyntaxContext};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{rename::remap, scope::ScopeKind};
use swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
pub(super) fn block_scoped_vars() -> impl VisitMut {
BlockScopedVars::default()
}
#[derive(Default)]
struct BlockScopedVars {
scope: Scope,
var_decl_kind: Option<VarDeclKind>,
is_param: bool,
}
#[derive(Debug, Default)]
struct Scope {
kind: ScopeKind,
vars: IndexMap<Id, VarDeclKind, FxBuildHasher>,
usages: Vec<Id>,
children: Vec<Scope>,
}
#[derive(Clone, Copy)]
struct ParentScope<'a> {
parent: Option<&'a ParentScope<'a>>,
vars: &'a IndexMap<Id, VarDeclKind, FxBuildHasher>,
}
#[swc_trace]
impl BlockScopedVars {
fn add_usage(&mut self, id: Id) {
if !self.scope.usages.contains(&id) {
self.scope.usages.push(id);
}
}
/// We rename declarations, not usages.
/// This is because we want to preserve access to global items.
///
/// But we use usages to potential conflicts, so we do it renaming in
/// multiple steps.
///
/// - For first, we collect all variables and usages.
///
/// - For second, we expand all usages to get list of symbols which may
/// conflict.
///
/// - For third, we rename all declarations which may conflict.
fn handle_program<N>(&mut self, n: &mut N)
where
N: VisitMutWith<Self> + for<'aa> VisitMutWith<dyn 'aa + VisitMut>,
{
n.visit_mut_children_with(self);
let empty_vars = Default::default();
let parent = ParentScope {
parent: None,
vars: &empty_vars,
};
let mut rename_map = FxHashMap::default();
// dbg!(&self.scope);
self.scope.rename(parent, &mut rename_map, true);
self.scope.rename(parent, &mut rename_map, false);
// dbg!(&rename_map);
n.visit_mut_with(&mut remap(&rename_map, Default::default()) as &mut dyn VisitMut);
}
fn with_scope(&mut self, kind: ScopeKind, op: impl FnOnce(&mut Self)) {
let scope = Scope {
kind,
..Default::default()
};
let mut v = BlockScopedVars { scope, ..*self };
op(&mut v);
if kind == ScopeKind::Block {
for (k, v) in &v.scope.vars {
if *v == VarDeclKind::Var {
self.scope.vars.insert(k.clone(), VarDeclKind::Var);
}
}
}
self.scope.children.push(v.scope);
}
}
#[swc_trace]
impl Scope {
fn rename(&mut self, parent: ParentScope, rename_map: &mut FxHashMap<Id, Id>, fn_only: bool) {
for s in self.children.iter_mut() {
let parent = ParentScope {
parent: Some(&parent),
vars: &self.vars,
};
s.rename(parent, rename_map, fn_only);
}
if fn_only && self.kind != ScopeKind::Fn {
return;
}
let mut symbols = Default::default();
self.collect_candidates(parent, &mut symbols);
// dbg!(&symbols);
self.rename_decls(&symbols, rename_map);
}
///
/// ## Falsy case
///
/// This returns false for the code below, because the variable `a` is
/// block-scoped.
///
/// ```js
/// {
/// let a = 1;
/// }
/// console.log(a)
/// ```
fn can_access(&self, id: &Id, parent: ParentScope, deny_let_const: bool) -> bool {
if parent.get_var(id).is_some() {
return true;
}
if let Some(kind) = self.vars.get(id).copied() {
if deny_let_const && matches!(kind, VarDeclKind::Let | VarDeclKind::Const) {
return false;
}
return true;
}
self.children.iter().any(|s| match s.kind {
ScopeKind::Block => s.can_access(id, parent, true),
ScopeKind::Fn => false,
})
}
fn remove_usage(&mut self, id: &Id) {
if let Some(pos) = self.usages.iter().position(|i| *i == *id) {
self.usages.remove(pos);
}
}
/// If a used identifier is declared in a child scope using `let` or
/// `const`, add it to `rename_map`.
fn collect_candidates(&mut self, parent: ParentScope, symbols: &mut Vec<Atom>) {
for id in &self.usages {
if self.can_access(id, parent, false) {
self.children.iter_mut().for_each(|s| {
s.remove_usage(id);
});
} else if !symbols.contains(&id.0) {
symbols.push(id.0.clone());
}
}
self.usages.clear();
let parent = ParentScope {
parent: Some(&parent),
vars: &self.vars,
};
self.children
.iter_mut()
.for_each(|s| s.collect_candidates(parent, symbols));
}
fn rename_decls(&self, symbols: &[Atom], rename_map: &mut FxHashMap<Id, Id>) {
for (id, _) in &self.vars {
if !symbols.contains(&id.0) {
continue;
}
if rename_map.contains_key(id) {
continue;
}
// We use _$ as prefix because other passes use `_` as prefix.
// (To avoid lots of renaming)
let sym = format!("_${}", id.0);
// We create a new syntax context instead of using original.
//
// This is required because
//
// {
// let a = 1;
// var _a = 2;
// }
//
// We can avoid this by detecting variable names, but using different syntax
// context is much easier.
let ctxt = SyntaxContext::empty().apply_mark(Mark::fresh(Mark::root()));
rename_map.insert(id.clone(), (sym.into(), ctxt));
}
self.children
.iter()
.for_each(|s| s.rename_decls(symbols, rename_map));
}
}
impl ParentScope<'_> {
fn get_var(&self, id: &Id) -> Option<VarDeclKind> {
if let Some(kind) = self.vars.get(id).copied() {
return Some(kind);
}
self.parent?.get_var(id)
}
}
#[swc_trace]
impl VisitMut for BlockScopedVars {
noop_visit_mut_type!(fail);
fn visit_mut_arrow_expr(&mut self, n: &mut ArrowExpr) {
self.with_scope(ScopeKind::Fn, |v| {
let old = v.is_param;
v.is_param = true;
n.params.visit_mut_with(v);
v.is_param = old;
match &mut *n.body {
BlockStmtOrExpr::BlockStmt(b) => {
b.visit_mut_children_with(v);
}
BlockStmtOrExpr::Expr(b) => {
b.visit_mut_with(v);
}
}
});
}
fn visit_mut_assign_pat_prop(&mut self, n: &mut AssignPatProp) {
n.visit_mut_children_with(self);
if let Some(kind) = self.var_decl_kind {
self.scope.vars.insert(n.key.to_id(), kind);
} else if !self.is_param {
self.add_usage(n.key.to_id())
}
}
fn visit_mut_binding_ident(&mut self, i: &mut BindingIdent) {
if let Some(kind) = self.var_decl_kind {
self.scope.vars.insert(i.to_id(), kind);
} else if !self.is_param {
self.add_usage(i.to_id())
}
}
fn visit_mut_block_stmt(&mut self, n: &mut BlockStmt) {
self.with_scope(ScopeKind::Block, |v| {
n.visit_mut_children_with(v);
});
}
fn visit_mut_catch_clause(&mut self, n: &mut CatchClause) {
let old_is_param = self.is_param;
self.is_param = true;
let old_var_decl_kind = self.var_decl_kind;
self.var_decl_kind = None;
n.visit_mut_children_with(self);
self.var_decl_kind = old_var_decl_kind;
self.is_param = old_is_param;
}
fn visit_mut_constructor(&mut self, n: &mut Constructor) {
self.with_scope(ScopeKind::Fn, |v| {
n.params.visit_mut_with(v);
if let Some(body) = &mut n.body {
body.visit_mut_children_with(v);
}
});
}
fn visit_mut_expr(&mut self, n: &mut Expr) {
let old_var_decl_kind = self.var_decl_kind;
self.var_decl_kind = None;
n.visit_mut_children_with(self);
if let Expr::Ident(i) = n {
self.add_usage(i.to_id());
}
self.var_decl_kind = old_var_decl_kind;
}
fn visit_mut_for_in_stmt(&mut self, n: &mut ForInStmt) {
n.right.visit_mut_with(self);
match &n.left {
ForHead::VarDecl(v)
if matches!(
&**v,
VarDecl {
kind: VarDeclKind::Let | VarDeclKind::Const,
..
}
) =>
{
self.with_scope(ScopeKind::Block, |v| {
n.left.visit_mut_with(v);
n.body.visit_mut_with(v);
});
}
_ => {
n.left.visit_mut_with(self);
n.body.visit_mut_with(self);
}
}
}
fn visit_mut_for_of_stmt(&mut self, n: &mut ForOfStmt) {
n.right.visit_mut_with(self);
match &n.left {
ForHead::VarDecl(v)
if matches!(
&**v,
VarDecl {
kind: VarDeclKind::Let | VarDeclKind::Const,
..
}
) =>
{
self.with_scope(ScopeKind::Block, |v| {
n.left.visit_mut_with(v);
n.body.visit_mut_with(v);
});
}
_ => {
n.left.visit_mut_with(self);
n.body.visit_mut_with(self);
}
}
}
fn visit_mut_for_stmt(&mut self, n: &mut ForStmt) {
match &n.init {
Some(VarDeclOrExpr::VarDecl(v))
if matches!(
&**v,
VarDecl {
kind: VarDeclKind::Let | VarDeclKind::Const,
..
}
) =>
{
self.with_scope(ScopeKind::Block, |v| {
n.init.visit_mut_with(v);
n.update.visit_mut_with(v);
n.test.visit_mut_with(v);
n.body.visit_mut_with(v);
});
}
_ => {
n.init.visit_mut_with(self);
n.update.visit_mut_with(self);
n.test.visit_mut_with(self);
n.body.visit_mut_with(self);
}
}
}
fn visit_mut_function(&mut self, n: &mut Function) {
n.decorators.visit_mut_with(self);
self.with_scope(ScopeKind::Fn, |v| {
n.params.visit_mut_with(v);
if let Some(body) = &mut n.body {
body.visit_mut_children_with(v);
}
});
}
fn visit_mut_module(&mut self, n: &mut Module) {
self.handle_program(n)
}
fn visit_mut_param(&mut self, n: &mut Param) {
let old_is_param = self.is_param;
self.is_param = true;
let old_var_decl_kind = self.var_decl_kind;
self.var_decl_kind = None;
n.visit_mut_children_with(self);
self.var_decl_kind = old_var_decl_kind;
self.is_param = old_is_param;
}
fn visit_mut_prop(&mut self, n: &mut Prop) {
n.visit_mut_children_with(self);
if let Prop::Shorthand(i) = n {
self.add_usage(i.to_id());
}
}
fn visit_mut_script(&mut self, n: &mut Script) {
self.handle_program(n)
}
fn visit_mut_var_decl(&mut self, n: &mut VarDecl) {
let old_var_decl_kind = self.var_decl_kind;
self.var_decl_kind = Some(n.kind);
n.visit_mut_children_with(self);
self.var_decl_kind = old_var_decl_kind;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/classes/constructor.rs | Rust | use std::mem;
use swc_common::{util::take::Take, Span, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{helper, helper_expr};
use swc_ecma_transforms_classes::super_field::SuperFieldAccessFolder;
use swc_ecma_utils::{default_constructor_with_span, private_ident, quote_ident, ExprFactory};
use swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
use tracing::debug;
use super::Config;
pub(super) fn fold_constructor(
class_span: Span,
constructor: Option<Constructor>,
class_name: &Ident,
class_super_name: &Option<Ident>,
config: Config,
) -> FnDecl {
let is_derived = class_super_name.is_some();
let mut constructor =
constructor.unwrap_or_else(|| default_constructor_with_span(is_derived, class_span));
// Black magic to detect injected constructor.
let is_constructor_default = constructor.span.is_dummy();
if is_constructor_default {
debug!("Dropping constructor parameters because the constructor is injected");
constructor.params.take();
}
let params = constructor
.params
.take()
.into_iter()
.map(|p| p.param().expect("All TS params should be converted"))
.collect();
let mut stmts = vec![];
if !config.no_class_calls {
// _class_call_check(this, C)
stmts.push(
CallExpr {
callee: helper!(class_call_check),
args: vec![
Expr::This(ThisExpr { span: DUMMY_SP }).as_arg(),
class_name.clone().as_arg(),
],
..Default::default()
}
.into_stmt(),
);
}
// handle super prop by default
let mut has_super_prop = true;
let mut this_mark = None;
let mut body = constructor.body.take().unwrap();
if let Some(class_super_name) = class_super_name {
let is_last_super = (&*body.stmts).is_super_last_call();
let is_last_return = body.stmts.last().map_or(false, Stmt::is_return_stmt);
let mut constructor_folder = ConstructorFolder {
class_key_init: vec![],
class_name: class_name.clone(),
class_super_name: class_super_name.clone(),
in_arrow: false,
in_nested_class: false,
is_constructor_default,
is_super_callable_constructor: config.super_is_callable_constructor,
super_found: false,
super_prop_found: false,
this: None,
this_ref_count: 0,
};
body.visit_mut_with(&mut constructor_folder);
// disable SuperFieldAccessFolder if super prop is not used
has_super_prop = constructor_folder.super_prop_found;
// Optimize for last super call
if is_last_super {
if let Some(stmt) = body.stmts.last_mut() {
if let Some(expr_stmt) = stmt.as_mut_expr() {
let span = expr_stmt.span;
match expr_stmt.expr.as_mut() {
Expr::Assign(assign) => {
let arg = if constructor_folder.this_ref_count == 1 {
constructor_folder.this_ref_count = 0;
assign.right.take()
} else {
assign.take().into()
};
*stmt = ReturnStmt {
span,
arg: arg.into(),
}
.into();
}
arg @ Expr::Seq(..) | arg @ Expr::Paren(..) => {
*stmt = ReturnStmt {
span,
arg: Some(Box::new(arg.take())),
}
.into();
}
_ => {}
}
};
}
}
if constructor_folder.this_ref_count > 0 || constructor_folder.super_prop_found {
let this = constructor_folder
.this
.get_or_insert_with(|| private_ident!("_this"))
.clone();
this_mark = Some(this.ctxt.outer());
let var = VarDeclarator {
name: Pat::Ident(this.into()),
span: DUMMY_SP,
init: None,
definite: false,
};
let var = VarDecl {
decls: vec![var],
..Default::default()
};
stmts.push(var.into());
}
if !is_last_super && !is_last_return {
let this = if constructor_folder.super_found {
Expr::Ident(constructor_folder.this.unwrap())
} else {
let this = constructor_folder
.this
.map_or_else(|| Expr::undefined(DUMMY_SP).as_arg(), |this| this.as_arg());
helper_expr!(assert_this_initialized).as_call(DUMMY_SP, vec![this])
};
let return_this = ReturnStmt {
span: DUMMY_SP,
arg: Some(this.into()),
};
body.stmts.push(return_this.into());
}
}
if has_super_prop {
let mut folder = SuperFieldAccessFolder {
class_name,
constructor_this_mark: this_mark,
// constructor cannot be static
is_static: false,
folding_constructor: true,
in_nested_scope: false,
in_injected_define_property_call: false,
this_alias_mark: None,
constant_super: config.constant_super,
super_class: class_super_name,
in_pat: false,
};
body.visit_mut_with(&mut folder);
if let Some(mark) = folder.this_alias_mark {
stmts.push(
VarDecl {
span: DUMMY_SP,
declare: false,
kind: VarDeclKind::Var,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: quote_ident!(SyntaxContext::empty().apply_mark(mark), "_this").into(),
init: Some(Box::new(Expr::This(ThisExpr { span: DUMMY_SP }))),
definite: false,
}],
..Default::default()
}
.into(),
)
}
}
stmts.extend(body.stmts);
let function = Function {
params,
body: Some(BlockStmt {
stmts,
..Default::default()
}),
..Default::default()
};
FnDecl {
ident: class_name.clone(),
declare: false,
function: function.into(),
}
}
struct ConstructorFolder {
class_key_init: Vec<Stmt>,
class_name: Ident,
class_super_name: Ident,
in_arrow: bool,
in_nested_class: bool,
is_constructor_default: bool,
is_super_callable_constructor: bool,
// super_found will be inherited from parent scope
// but it should be reset when exiting from the conditional scope
// e.g. if/while/for/try
super_found: bool,
super_prop_found: bool,
this: Option<Ident>,
this_ref_count: usize,
}
#[swc_trace]
impl VisitMut for ConstructorFolder {
noop_visit_mut_type!(fail);
fn visit_mut_constructor(&mut self, _: &mut Constructor) {
// skip
}
fn visit_mut_function(&mut self, _: &mut Function) {
// skip
}
fn visit_mut_getter_prop(&mut self, _: &mut GetterProp) {
// skip
}
fn visit_mut_setter_prop(&mut self, _: &mut SetterProp) {
// skip
}
fn visit_mut_if_stmt(&mut self, node: &mut IfStmt) {
node.test.visit_mut_with(self);
let super_found = self.super_found;
node.cons.visit_mut_with(self);
node.alt.visit_mut_with(self);
self.super_found = super_found;
}
fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
node.test.visit_mut_with(self);
let super_found = self.super_found;
node.body.visit_mut_with(self);
self.super_found = super_found;
}
fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
node.test.visit_mut_with(self);
let super_found = self.super_found;
node.body.visit_mut_with(self);
self.super_found = super_found;
}
fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
node.init.visit_mut_with(self);
node.test.visit_mut_with(self);
let super_found = self.super_found;
node.body.visit_mut_with(self);
node.update.visit_mut_with(self);
self.super_found = super_found;
}
fn visit_mut_for_of_stmt(&mut self, node: &mut ForOfStmt) {
node.left.visit_mut_with(self);
node.right.visit_mut_with(self);
let super_found = self.super_found;
node.body.visit_mut_with(self);
self.super_found = super_found;
}
fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
node.left.visit_mut_with(self);
node.right.visit_mut_with(self);
let super_found = self.super_found;
node.body.visit_mut_with(self);
self.super_found = super_found;
}
fn visit_mut_cond_expr(&mut self, node: &mut CondExpr) {
node.test.visit_mut_with(self);
let super_found = self.super_found;
node.cons.visit_mut_with(self);
node.alt.visit_mut_with(self);
self.super_found = super_found;
}
fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
node.discriminant.visit_mut_with(self);
let super_found = self.super_found;
node.cases.visit_mut_with(self);
self.super_found = super_found;
}
fn visit_mut_try_stmt(&mut self, node: &mut TryStmt) {
let super_found = self.super_found;
node.block.visit_mut_with(self);
node.handler.visit_mut_with(self);
self.super_found = super_found;
node.finalizer.visit_mut_with(self);
}
fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
if node.body.is_block() {
let super_found = self.super_found;
node.body.visit_mut_with(self);
self.super_found = super_found;
} else {
node.body.visit_mut_with(self);
}
}
fn visit_mut_bin_expr(&mut self, node: &mut BinExpr) {
match node.op {
op!("&&") | op!("||") => {
node.left.visit_mut_with(self);
let super_found = self.super_found;
node.right.visit_mut_with(self);
self.super_found = super_found;
}
_ => {
node.visit_mut_children_with(self);
}
}
}
fn visit_mut_class(&mut self, node: &mut Class) {
let in_nested_class = mem::replace(&mut self.in_nested_class, true);
node.visit_mut_children_with(self);
self.in_nested_class = in_nested_class;
}
fn visit_mut_arrow_expr(&mut self, node: &mut ArrowExpr) {
let in_arrow = mem::replace(&mut self.in_arrow, true);
let super_found = self.super_found;
node.visit_mut_children_with(self);
self.super_found = super_found;
self.in_arrow = in_arrow;
}
fn visit_mut_stmts(&mut self, node: &mut Vec<Stmt>) {
for mut stmt in node.take().drain(..) {
stmt.visit_mut_with(self);
let class_key_init = self.class_key_init.take();
if !class_key_init.is_empty() {
node.extend(class_key_init);
}
node.push(stmt);
}
}
fn visit_mut_expr(&mut self, node: &mut Expr) {
if node.is_this() {
if !self.super_found {
*node = helper_expr!(assert_this_initialized)
.as_call(DUMMY_SP, vec![self.get_this().clone().as_arg()]);
} else {
*node = self.get_this().clone().into();
}
return;
}
node.visit_mut_children_with(self);
if self.transform_super_call(node) {
self.super_found = true;
let this = self.get_this().clone();
let assign_expr = node.take().make_assign_to(op!("="), this.clone().into());
if self.in_nested_class {
self.class_key_init.push(assign_expr.into_stmt());
*node = this.into();
} else {
*node = assign_expr;
}
}
}
fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
node.visit_mut_children_with(self);
if !self.in_arrow {
let arg = node.arg.take().map(ExprFactory::as_arg);
let mut args = vec![self.get_this().clone().as_arg()];
args.extend(arg);
node.arg = Some(
helper_expr!(possible_constructor_return)
.as_call(DUMMY_SP, args)
.into(),
);
}
}
fn visit_mut_super_prop(&mut self, node: &mut SuperProp) {
self.super_prop_found = true;
node.visit_mut_children_with(self);
}
}
#[swc_trace]
impl ConstructorFolder {
fn get_this(&mut self) -> &Ident {
self.this_ref_count += 1;
self.this.get_or_insert_with(|| private_ident!("_this"))
}
fn transform_super_call(&self, node: &mut Expr) -> bool {
let Expr::Call(call_expr) = node else {
return false;
};
let CallExpr {
callee: callee @ Callee::Super(..),
args: origin_args,
..
} = call_expr
else {
return false;
};
if self.is_super_callable_constructor {
if self.is_constructor_default || is_spread_arguements(origin_args) {
*callee = self
.class_super_name
.clone()
.make_member(quote_ident!("apply"))
.as_callee();
let mut arguments = quote_ident!("arguments");
if let Some(e) = origin_args.first() {
arguments.span = e.expr.span()
}
*origin_args = vec![ThisExpr { span: DUMMY_SP }.as_arg(), arguments.as_arg()];
} else {
*callee = self
.class_super_name
.clone()
.make_member(quote_ident!("call"))
.as_callee();
origin_args.insert(0, ThisExpr { span: DUMMY_SP }.as_arg());
}
*node = BinExpr {
span: DUMMY_SP,
left: Box::new(node.take()),
op: op!("||"),
right: Box::new(Expr::This(ThisExpr { span: DUMMY_SP })),
}
.into();
return true;
}
*callee = helper!(call_super);
let mut args = vec![
ThisExpr { span: DUMMY_SP }.as_arg(),
self.class_name.clone().as_arg(),
];
if self.is_constructor_default || is_spread_arguements(origin_args) {
// super(...arguments)
// _call_super(this, _super_class_name, ...arguments)
let mut arguments = quote_ident!("arguments");
if let Some(e) = origin_args.first() {
arguments.span = e.expr.span()
}
args.push(arguments.as_arg())
} else if !origin_args.is_empty() {
// super(a, b)
// _call_super(this, _super_class_name, [a, b])
let array = ArrayLit {
elems: origin_args.take().into_iter().map(Some).collect(),
..Default::default()
};
args.push(array.as_arg());
}
*origin_args = args;
true
}
}
// ...arguments
fn is_spread_arguements(args: &[ExprOrSpread]) -> bool {
if args.len() != 1 {
return false;
}
let arg = &args[0];
if arg.spread.is_none() {
return false;
}
arg.expr
.as_ident()
.filter(|ident| ident.sym == *"arguments")
.is_some()
}
trait SuperLastCall {
fn is_super_last_call(&self) -> bool;
}
impl SuperLastCall for &[Stmt] {
fn is_super_last_call(&self) -> bool {
self.iter()
.rev()
.find(|s| !s.is_empty())
.map_or(false, |s| s.is_super_last_call())
}
}
impl SuperLastCall for &Stmt {
fn is_super_last_call(&self) -> bool {
match self {
Stmt::Expr(ExprStmt { expr, .. }) => (&**expr).is_super_last_call(),
Stmt::Return(ReturnStmt { arg: Some(arg), .. }) => (&**arg).is_super_last_call(),
_ => false,
}
}
}
impl SuperLastCall for &Expr {
fn is_super_last_call(&self) -> bool {
match self {
Expr::Call(CallExpr {
callee: Callee::Super(..),
..
}) => true,
Expr::Paren(ParenExpr { expr, .. }) => (&**expr).is_super_last_call(),
Expr::Seq(SeqExpr { exprs, .. }) => {
exprs.last().map_or(false, |e| (&**e).is_super_last_call())
}
_ => false,
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/classes/mod.rs | Rust | use std::iter;
use rustc_hash::FxBuildHasher;
use serde::Deserialize;
use swc_common::{util::take::Take, BytePos, Mark, Span, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{helper, native::is_native, perf::Check};
use swc_ecma_transforms_classes::super_field::SuperFieldAccessFolder;
use swc_ecma_transforms_macros::fast_path;
use swc_ecma_utils::{
alias_if_required, contains_this_expr, is_valid_ident, is_valid_prop_ident, prepend_stmt,
private_ident, prop_name_to_expr, quote_expr, quote_ident, quote_str, replace_ident,
ExprFactory, ModuleItemLike, StmtLike,
};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith, VisitWith,
};
use swc_trace_macro::swc_trace;
use self::{
constructor::fold_constructor,
prop_name::{is_pure_prop_name, should_extract_class_prop_key, HashKey},
};
mod constructor;
mod prop_name;
pub fn classes(config: Config) -> impl Pass {
visit_mut_pass(Classes {
in_strict: false,
config,
params: Default::default(),
args: Default::default(),
})
}
type IndexMap<K, V> = indexmap::IndexMap<K, V, FxBuildHasher>;
/// `@babel/plugin-transform-classes`
///
/// # In
/// ```js
/// class Test {
/// constructor(name) {
/// this.name = name;
/// }
///
/// logger () {
/// console.log("Hello", this.name);
/// }
/// }
/// ```
///
/// # Out
/// ```js
/// var Test = function () {
/// function Test(name) {
/// _class_call_check(this, Test);
///
/// this.name = name;
/// }
///
/// Test.prototype.logger = function logger() {
/// console.log("Hello", this.name);
/// };
///
/// return Test;
/// }();
/// ```
#[derive(Default, Clone)]
struct Classes {
in_strict: bool,
config: Config,
params: Vec<Param>,
args: Vec<ExprOrSpread>,
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
#[serde(default)]
pub constant_super: bool,
#[serde(default)]
pub no_class_calls: bool,
#[serde(default)]
pub set_class_methods: bool,
#[serde(default)]
pub super_is_callable_constructor: bool,
}
struct Data {
key_prop: Box<PropName>,
method: Option<Box<Expr>>,
set: Option<Box<Expr>>,
get: Option<Box<Expr>>,
}
#[swc_trace]
impl Classes {
fn visit_mut_stmt_like<T>(&mut self, stmts: &mut Vec<T>)
where
T: StmtLike + ModuleItemLike + VisitMutWith<Self> + Take,
{
let mut buf = Vec::with_capacity(stmts.len());
let mut first = true;
let old = self.in_strict;
for stmt in stmts.iter_mut() {
match T::try_into_stmt(stmt.take()) {
Err(node) => match node.try_into_module_decl() {
Ok(mut decl) => {
match decl {
ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {
decl: DefaultDecl::Class(ClassExpr { ident, class }),
..
}) => {
let ident =
ident.unwrap_or_else(|| quote_ident!("_default").into());
let mut decl = self.fold_class_as_var_decl(ident.clone(), class);
decl.visit_mut_children_with(self);
buf.push(T::from(decl.into()));
buf.push(
match T::try_from_module_decl(
NamedExport {
span: DUMMY_SP,
specifiers: vec![ExportNamedSpecifier {
span: DUMMY_SP,
orig: ModuleExportName::Ident(ident),
exported: Some(ModuleExportName::Ident(
quote_ident!("default").into(),
)),
is_type_only: false,
}
.into()],
src: None,
type_only: false,
with: None,
}
.into(),
) {
Ok(t) => t,
Err(..) => unreachable!(),
},
);
}
ModuleDecl::ExportDecl(ExportDecl {
span,
decl:
Decl::Class(ClassDecl {
ident,
declare: false,
class,
}),
..
}) => {
let mut decl = self.fold_class_as_var_decl(ident, class);
decl.visit_mut_children_with(self);
buf.push(
match T::try_from_module_decl(
ExportDecl {
span,
decl: decl.into(),
}
.into(),
) {
Ok(t) => t,
Err(..) => unreachable!(),
},
);
}
_ => buf.push({
decl.visit_mut_children_with(self);
match T::try_from_module_decl(decl) {
Ok(t) => t,
Err(..) => unreachable!(),
}
}),
};
}
Err(..) => unreachable!(),
},
Ok(mut stmt) => {
if first {
self.in_strict |= stmt.is_use_strict();
}
stmt.visit_mut_children_with(self);
buf.push(T::from(stmt));
}
}
first = false;
}
self.in_strict = old;
*stmts = buf;
}
}
#[swc_trace]
#[fast_path(ClassFinder)]
impl VisitMut for Classes {
noop_visit_mut_type!(fail);
fn visit_mut_module_items(&mut self, items: &mut Vec<ModuleItem>) {
self.visit_mut_stmt_like(items)
}
fn visit_mut_stmts(&mut self, items: &mut Vec<Stmt>) {
self.visit_mut_stmt_like(items)
}
fn visit_mut_decl(&mut self, n: &mut Decl) {
if let Decl::Class(decl) = n {
*n = self
.fold_class_as_var_decl(decl.ident.take(), decl.class.take())
.into()
};
n.visit_mut_children_with(self);
}
fn visit_mut_expr(&mut self, n: &mut Expr) {
match n {
Expr::Class(e) => {
let mut class = self.fold_class(e.ident.take(), e.class.take());
if let Expr::Call(call) = &mut class {
self.add_pure_comments(&mut call.span.lo)
}
*n = class;
n.visit_mut_children_with(self)
}
_ => n.visit_mut_children_with(self),
}
}
fn visit_mut_var_declarator(&mut self, d: &mut VarDeclarator) {
// will there be anything else in var name at this point?
if let VarDeclarator {
name: Pat::Ident(i),
init: Some(init),
..
} = d
{
if let Expr::Class(c @ ClassExpr { ident: None, .. }) = &mut **init {
c.ident = Some(Ident::from(&*i).into_private())
}
}
d.visit_mut_children_with(self)
}
/// `let { f = class /* f */ {} } = {};`
fn visit_mut_assign_pat_prop(&mut self, n: &mut AssignPatProp) {
if let Some(value) = &mut n.value {
if let Expr::Class(c @ ClassExpr { ident: None, .. }) = &mut **value {
c.ident = Some(Ident::from(&n.key).into_private());
}
}
n.visit_mut_children_with(self);
}
/// `let [c = class /* c */ {}] = [];`
/// `function foo(bar = class /* bar */ {}) {}`
fn visit_mut_assign_pat(&mut self, n: &mut AssignPat) {
if let (Pat::Ident(id), Expr::Class(c @ ClassExpr { ident: None, .. })) =
(&*n.left, &mut *n.right)
{
c.ident = Some(Ident::from(id).into_private());
}
n.visit_mut_children_with(self);
}
/// {
/// hello: class {},
/// "foo": class {},
/// ["x"]: class {}
/// }
fn visit_mut_key_value_prop(&mut self, n: &mut KeyValueProp) {
if let Expr::Class(c @ ClassExpr { ident: None, .. }) = &mut *n.value {
match &n.key {
PropName::Ident(ident) => {
c.ident = Some(Ident::from(ident.clone()).into_private());
}
PropName::Str(Str { value, span, .. }) => {
if is_valid_prop_ident(value) {
c.ident = Some(private_ident!(*span, value.clone()));
}
}
PropName::Computed(ComputedPropName { expr, .. }) => {
if let Expr::Lit(Lit::Str(Str { value, span, .. })) = &**expr {
if is_valid_prop_ident(value) {
c.ident = Some(private_ident!(*span, value.clone()));
}
}
}
_ => {}
}
}
n.visit_mut_children_with(self)
}
fn visit_mut_assign_expr(&mut self, a: &mut AssignExpr) {
if let AssignExpr {
op: op!("=") | op!("||=") | op!("??="),
left,
right,
..
} = a
{
if let Expr::Class(c @ ClassExpr { ident: None, .. }) = &mut **right {
if let AssignTarget::Simple(SimpleAssignTarget::Ident(ident)) = left {
c.ident = Some(Ident::from(&*ident).into_private())
}
}
}
a.visit_mut_children_with(self)
}
}
#[swc_trace]
impl Classes {
fn add_pure_comments(&mut self, start: &mut BytePos) {
*start = BytePos::PURE;
}
fn fold_class_as_var_decl(&mut self, ident: Ident, class: Box<Class>) -> VarDecl {
let span = class.span;
let mut rhs = self.fold_class(Some(ident.clone()), class);
let mut new_name = ident.clone();
new_name.ctxt = new_name.ctxt.apply_mark(Mark::new());
replace_ident(&mut rhs, ident.to_id(), &new_name);
// let VarDecl take every comments except pure
if let Expr::Call(call) = &mut rhs {
let mut span = Span {
// after class
lo: span.lo + BytePos(5),
..span
};
self.add_pure_comments(&mut span.lo);
call.span = span;
}
VarDecl {
span,
kind: VarDeclKind::Let,
decls: vec![VarDeclarator {
span,
init: Some(Box::new(rhs)),
// Foo in var Foo =
name: ident.into(),
definite: false,
}],
..Default::default()
}
}
/// Turns class expression into iife.
///
/// ```js
/// class Foo {}
/// ```
///
/// ```js
/// function() {
/// var Foo = function Foo(){
/// };
/// }()
/// ```
fn fold_class(&mut self, class_name: Option<Ident>, class: Box<Class>) -> Expr {
let span = class.span;
// Ident of the super class *inside* function.
let super_ident = class
.super_class
.as_ref()
.map(|e| alias_if_required(e, "_superClass").0);
let has_super = super_ident.is_some();
let (mut params, mut args, super_ident) = if let Some(ref super_ident) = super_ident {
// Param should have a separate syntax context from arg.
let super_param = private_ident!(super_ident.sym.clone());
let params = vec![Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: super_param.clone().into(),
}];
let super_class = class.super_class.clone().unwrap();
let is_super_native = match *super_class {
Expr::Ident(Ident { ref sym, .. }) => is_native(sym),
_ => false,
};
if is_super_native {
(
params,
vec![CallExpr {
span: DUMMY_SP,
callee: helper!(wrap_native_super),
args: vec![super_class.as_arg()],
..Default::default()
}
.as_arg()],
Some(super_param),
)
} else {
(params, vec![super_class.as_arg()], Some(super_param))
}
} else {
(Vec::new(), Vec::new(), None)
};
let mut stmts = self.class_to_stmts(class_name, super_ident, class);
params.extend(self.params.take());
args.extend(self.args.take());
let cnt_of_non_directive = stmts
.iter()
.filter(|stmt| match stmt {
Stmt::Expr(ExprStmt { expr, .. }) => !matches!(&**expr, Expr::Lit(Lit::Str(..))),
_ => true,
})
.count();
if !has_super && cnt_of_non_directive == 1 {
// class Foo {}
//
// should be
//
// var Foo = function Foo() {
// _class_call_check(this, Foo);
// };
//
// instead of
//
// var Foo = function(){
// function Foo() {
// _class_call_check(this, Foo);
// }
//
// return Foo;
// }();
let stmt = stmts.pop().unwrap();
match stmt {
Stmt::Decl(Decl::Fn(FnDecl {
ident,
mut function,
..
})) => {
if let Some(use_strict) = stmts.pop() {
prepend_stmt(&mut function.body.as_mut().unwrap().stmts, use_strict);
}
function.span = span;
return FnExpr {
ident: Some(ident),
function,
}
.into();
}
_ => unreachable!(),
}
}
let body = BlockStmt {
span: DUMMY_SP,
stmts,
..Default::default()
};
let call = CallExpr {
span,
callee: Function {
span,
is_async: false,
is_generator: false,
params,
body: Some(body),
..Default::default()
}
.as_callee(),
args,
..Default::default()
};
call.into()
}
/// Returned `stmts` contains `return Foo`
fn class_to_stmts(
&mut self,
class_name: Option<Ident>,
super_class_ident: Option<Ident>,
class: Box<Class>,
) -> Vec<Stmt> {
let class_name = class_name.unwrap_or_else(|| quote_ident!("_class").into());
let mut stmts = Vec::new();
let mut methods = Vec::new();
let mut constructor = None;
for member in class.body {
match member {
ClassMember::Constructor(c) => constructor = Some(c),
ClassMember::Method(m) => methods.push(m),
ClassMember::PrivateMethod(_)
| ClassMember::ClassProp(..)
| ClassMember::PrivateProp(..)
| ClassMember::TsIndexSignature(..)
| ClassMember::StaticBlock(..)
| ClassMember::AutoAccessor(..) => {}
ClassMember::Empty(..) => {}
}
}
if let Some(ref super_class_ident) = super_class_ident {
// inject helper methods
let mut class_name_sym = class_name.clone();
class_name_sym.span = DUMMY_SP;
class_name_sym.ctxt = class_name.ctxt;
let mut super_class_name_sym = super_class_ident.clone();
super_class_name_sym.span = DUMMY_SP;
super_class_name_sym.ctxt = super_class_ident.ctxt;
stmts.push(
CallExpr {
span: DUMMY_SP,
callee: helper!(inherits),
args: vec![class_name_sym.as_arg(), super_class_name_sym.as_arg()],
..Default::default()
}
.into_stmt(),
);
}
// constructor
stmts.push(
fold_constructor(
class.span,
constructor,
&class_name,
&super_class_ident,
self.config,
)
.into(),
);
// convert class methods
stmts.extend(self.fold_class_methods(&class_name, &super_class_ident, methods));
if stmts.first().map(|v| !v.is_use_strict()).unwrap_or(false) && !self.in_strict {
prepend_stmt(
&mut stmts,
Lit::Str(Str {
span: DUMMY_SP,
value: "use strict".into(),
raw: Some("\"use strict\"".into()),
})
.into_stmt(),
);
if stmts.len() == 2 {
return stmts;
}
}
if super_class_ident.is_none()
&& stmts
.iter()
.filter(|stmt| match stmt {
Stmt::Expr(ExprStmt { expr, .. }) => {
!matches!(&**expr, Expr::Lit(Lit::Str(..)))
}
_ => true,
})
.count()
== 1
{
return stmts;
}
let mut class_name_sym = class_name.clone();
class_name_sym.span = DUMMY_SP;
class_name_sym.ctxt = class_name.ctxt;
// `return Foo`
stmts.push(
ReturnStmt {
span: DUMMY_SP,
arg: Some(class_name_sym.into()),
}
.into(),
);
stmts
}
fn fold_class_methods(
&mut self,
class_name: &Ident,
super_class_ident: &Option<Ident>,
methods: Vec<ClassMethod>,
) -> Vec<Stmt> {
if methods.is_empty() {
return Vec::new();
}
/// { key: "prop" }
fn mk_key_prop(key: PropName) -> Box<Prop> {
Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident(quote_ident!(Default::default(), key.span(), "key").into()),
value: match key {
PropName::Ident(i) => Lit::Str(quote_str!(i.span, i.sym)).into(),
PropName::Str(s) => s.into(),
PropName::Num(n) => n.into(),
PropName::BigInt(b) => Str {
span: b.span,
raw: None,
value: b.value.to_string().into(),
}
.into(),
PropName::Computed(c) => c.expr,
},
}))
}
fn mk_key_prop_member(key: PropName) -> MemberProp {
match key {
PropName::Ident(i) => MemberProp::Ident(i),
PropName::Str(s) => MemberProp::Computed(ComputedPropName {
span: s.span,
expr: Lit::Str(s).into(),
}),
PropName::Num(n) => MemberProp::Computed(ComputedPropName {
span: n.span,
expr: Lit::Num(n).into(),
}),
PropName::BigInt(b) => MemberProp::Computed(ComputedPropName {
span: b.span,
expr: Str {
span: b.span,
raw: None,
value: b.value.to_string().into(),
}
.into(),
}),
PropName::Computed(c) => MemberProp::Computed(c),
}
}
fn mk_arg_obj_for_create_class(props: IndexMap<HashKey, Data>) -> ExprOrSpread {
if props.is_empty() {
return quote_expr!(DUMMY_SP, null).as_arg();
}
ArrayLit {
span: DUMMY_SP,
elems: props
.into_iter()
.map(|(_, data)| {
let mut props = vec![PropOrSpread::Prop(mk_key_prop(*data.key_prop))];
macro_rules! add {
($field:expr, $kind:expr, $s:literal) => {{
if let Some(value) = $field {
let value = escape_keywords(value);
props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(
KeyValueProp {
key: PropName::Ident(quote_ident!($s)),
value,
},
))));
}
}};
}
add!(data.get, MethodKind::Getter, "get");
add!(data.set, MethodKind::Setter, "set");
add!(data.method, MethodKind::Method, "value");
ObjectLit {
span: DUMMY_SP,
props,
}
.as_arg()
})
.map(Some)
.collect(),
}
.as_arg()
}
/// _create_class(Foo, [{}], [{}]);
fn mk_create_class_call(
class_name: Ident,
methods: ExprOrSpread,
static_methods: Option<ExprOrSpread>,
) -> Stmt {
let mut class_name_sym = class_name.clone();
class_name_sym.span = DUMMY_SP;
class_name_sym.ctxt = class_name.ctxt;
CallExpr {
span: DUMMY_SP,
callee: helper!(create_class),
args: iter::once(class_name_sym.as_arg())
.chain(iter::once(methods))
.chain(static_methods)
.collect(),
..Default::default()
}
.into_stmt()
}
let (mut props, mut static_props) = (IndexMap::default(), IndexMap::default());
let should_extract = should_extract_class_prop_key(&methods);
for mut m in methods {
let key = HashKey::from(&m.key);
let key_is_pure = is_pure_prop_name(&m.key);
// class is always strict, however computed key is not part of class
let key_contain_this = !self.in_strict && contains_this_expr(&m.key);
let key_prop = Box::new(m.key.clone());
let computed = matches!(m.key, PropName::Computed(..));
let prop_name = prop_name_to_expr(m.key);
let key_prop = if should_extract && !key_is_pure || key_contain_this {
let ident = private_ident!("_prop");
self.params.push(ident.clone().into());
self.args.push(prop_name.clone().into());
Box::new(PropName::Computed(ComputedPropName {
span: DUMMY_SP,
expr: Box::new(ident.into()),
}))
} else {
key_prop
};
let append_to: &mut IndexMap<_, _> = if m.is_static {
&mut static_props
} else {
&mut props
};
let mut folder = SuperFieldAccessFolder {
class_name,
constructor_this_mark: None,
is_static: m.is_static,
folding_constructor: false,
in_nested_scope: false,
in_injected_define_property_call: false,
this_alias_mark: None,
constant_super: self.config.constant_super,
super_class: super_class_ident,
in_pat: false,
};
m.function.visit_mut_with(&mut folder);
if let Some(mark) = folder.this_alias_mark {
prepend_stmt(
&mut m.function.body.as_mut().unwrap().stmts,
VarDecl {
span: DUMMY_SP,
declare: false,
kind: VarDeclKind::Var,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: quote_ident!(SyntaxContext::empty().apply_mark(mark), "_this")
.into(),
init: Some(Box::new(Expr::This(ThisExpr { span: DUMMY_SP }))),
definite: false,
}],
..Default::default()
}
.into(),
);
}
let value = FnExpr {
ident: if m.kind == MethodKind::Method && !computed {
match prop_name {
Expr::Ident(ident) => Some(private_ident!(ident.span, ident.sym)),
Expr::Lit(Lit::Str(Str { span, value, .. })) if is_valid_ident(&value) => {
Some(Ident::new(
value,
span,
SyntaxContext::empty().apply_mark(Mark::new()),
))
}
_ => None,
}
} else {
None
},
function: m.function,
}
.into();
let data = append_to.entry(key).or_insert_with(|| Data {
key_prop,
get: None,
set: None,
method: None,
});
match m.kind {
// https://github.com/swc-project/swc/issues/5029
MethodKind::Getter => {
data.method = None;
data.get = Some(value)
}
MethodKind::Setter => {
data.method = None;
data.set = Some(value)
}
MethodKind::Method => {
data.get = None;
data.set = None;
data.method = Some(value)
}
}
}
let mut res = Vec::new();
if self.config.set_class_methods {
let proto = private_ident!("_proto");
props.retain(|_, v| {
if let Some(method) = v.method.take() {
if res.is_empty() {
res.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: proto.clone().into(),
init: Some(
class_name
.clone()
.make_member(quote_ident!("prototype"))
.into(),
),
definite: false,
}],
..Default::default()
}
.into(),
);
}
let span = method.span();
let prop = *v.key_prop.clone();
res.push(
ExprStmt {
span,
expr: AssignExpr {
span,
op: op!("="),
left: MemberExpr {
span,
obj: Box::new(proto.clone().into()),
prop: mk_key_prop_member(prop),
}
.into(),
right: escape_keywords(method),
}
.into(),
}
.into(),
);
!(v.get.is_none() && v.set.is_none())
} else {
true
}
});
static_props.retain(|_, v| {
if let Some(method) = v.method.take() {
let span = method.span();
let prop = *v.key_prop.clone();
res.push(
ExprStmt {
span,
expr: AssignExpr {
span,
op: op!("="),
left: MemberExpr {
span,
obj: Box::new(class_name.clone().into()),
prop: mk_key_prop_member(prop),
}
.into(),
right: escape_keywords(method),
}
.into(),
}
.into(),
);
!(v.get.is_none() && v.set.is_none())
} else {
true
}
})
}
if props.is_empty() && static_props.is_empty() {
return res;
}
res.push(mk_create_class_call(
class_name.clone(),
mk_arg_obj_for_create_class(props),
if static_props.is_empty() {
None
} else {
Some(mk_arg_obj_for_create_class(static_props))
},
));
res
}
}
#[tracing::instrument(level = "info", skip_all)]
fn inject_class_call_check(c: &mut Vec<Stmt>, name: Ident) {
let mut class_name_sym = name.clone();
class_name_sym.span = DUMMY_SP;
class_name_sym.ctxt = name.ctxt;
let class_call_check = CallExpr {
span: DUMMY_SP,
callee: helper!(class_call_check),
args: vec![
Expr::This(ThisExpr { span: DUMMY_SP }).as_arg(),
class_name_sym.as_arg(),
],
..Default::default()
}
.into_stmt();
prepend_stmt(c, class_call_check)
}
/// Returns true if no `super` is used before `super()` call.
#[tracing::instrument(level = "info", skip_all)]
fn is_always_initialized(body: &[Stmt]) -> bool {
struct SuperFinder {
found: bool,
}
impl Visit for SuperFinder {
noop_visit_type!(fail);
fn visit_callee(&mut self, node: &Callee) {
match *node {
Callee::Super(..) => self.found = true,
_ => node.visit_children_with(self),
}
}
fn visit_super_prop_expr(&mut self, _: &SuperPropExpr) {
self.found = true
}
}
let pos = match body.iter().position(|s| match s {
Stmt::Expr(ExprStmt { expr, .. }) => matches!(
&**expr,
Expr::Call(CallExpr {
callee: Callee::Super(..),
..
})
),
_ => false,
}) {
Some(pos) => pos,
_ => return false,
};
let mut v = SuperFinder { found: false };
let body = &body[..pos];
v.visit_stmts(body);
!v.found
}
fn escape_keywords(mut e: Box<Expr>) -> Box<Expr> {
if let Expr::Fn(f) = &mut *e {
if let Some(i) = &mut f.ident {
let sym = Ident::verify_symbol(&i.sym);
if let Err(new) = sym {
i.sym = new.into();
}
}
}
e
}
#[derive(Default)]
struct ClassFinder {
found: bool,
}
impl Visit for ClassFinder {
noop_visit_type!(fail);
fn visit_class(&mut self, _: &Class) {
self.found = true
}
}
impl Check for ClassFinder {
fn should_handle(&self) -> bool {
self.found
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/classes/prop_name.rs | Rust | use swc_atoms::Atom;
use swc_common::{Span, Spanned};
use swc_ecma_ast::*;
#[derive(Debug, PartialEq, Eq, Hash)]
pub enum HashKey {
Str(Atom),
/// Not for key merging
Computed(Span),
}
impl From<&PropName> for HashKey {
fn from(p: &PropName) -> Self {
match p {
PropName::Ident(IdentName { sym: value, .. }) | PropName::Str(Str { value, .. }) => {
HashKey::Str(value.clone())
}
PropName::Num(Number { value, .. }) => HashKey::Str(value.to_string().into()),
PropName::BigInt(BigInt { value, .. }) => HashKey::Str(value.to_string().into()),
PropName::Computed(expr) => HashKey::Computed(expr.span()),
}
}
}
pub fn is_pure_prop_name(p: &PropName) -> bool {
match p {
PropName::Ident(..) => true,
PropName::Str(..) => true,
PropName::Num(..) => true,
PropName::BigInt(..) => true,
PropName::Computed(ComputedPropName { expr, .. }) => match &**expr {
Expr::This(..) => true,
Expr::Lit(..) => true,
Expr::Ident(..) => true,
Expr::PrivateName(..) => true,
Expr::Tpl(tpl) => tpl.exprs.is_empty(),
_ => false,
},
}
}
pub fn should_extract_class_prop_key(methods: &[ClassMethod]) -> bool {
let mut has_static = false;
for m in methods {
if is_pure_prop_name(&m.key) {
continue;
}
if m.is_static {
has_static = true
} else if has_static {
return true;
}
}
false
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/computed_props.rs | Rust | use serde::Deserialize;
use swc_common::{Mark, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::helper;
use swc_ecma_utils::{quote_ident, ExprFactory, StmtLike};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith, VisitWith,
};
use swc_trace_macro::swc_trace;
/// `@babel/plugin-transform-computed-properties`
///
/// # Example
/// ## In
///
/// ```js
/// var obj = {
/// ["x" + foo]: "heh",
/// ["y" + bar]: "noo",
/// foo: "foo",
/// bar: "bar"
/// };
/// ```
///
/// ## Out
///
/// ```js
/// var _obj;
///
/// var obj = (
/// _obj = {},
/// _define_property(_obj, "x" + foo, "heh"),
/// _define_property(_obj, "y" + bar, "noo"),
/// _define_property(_obj, "foo", "foo"),
/// _define_property(_obj, "bar", "bar"),
/// _obj
/// );
/// ```
///
/// TODO(kdy1): cache reference like (_f = f, mutatorMap[_f].get = function(){})
/// instead of (mutatorMap[f].get = function(){}
pub fn computed_properties(c: Config) -> impl Pass {
visit_mut_pass(ComputedProps {
c,
..Default::default()
})
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
#[serde(default)]
pub loose: bool,
}
#[derive(Default)]
struct ComputedProps {
vars: Vec<VarDeclarator>,
used_define_enum_props: bool,
c: Config,
}
#[swc_trace]
impl VisitMut for ComputedProps {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Expr::Object(ObjectLit { props, span }) = expr {
if !is_complex(props) {
return;
}
let mark = Mark::fresh(Mark::root());
let obj_ident = quote_ident!(SyntaxContext::empty().apply_mark(mark), *span, "_obj");
let mut exprs: Vec<Box<Expr>> = Vec::with_capacity(props.len() + 2);
let mutator_map = quote_ident!(
SyntaxContext::empty().apply_mark(mark),
*span,
"_mutatorMap"
);
// Optimization
let obj_props = {
let idx = props.iter().position(is_complex).unwrap_or(0);
props.drain(0..idx).collect()
};
let props_cnt = props.len();
self.used_define_enum_props = props.iter().any(
|pp| matches!(*pp, PropOrSpread::Prop(ref p) if p.is_getter() || p.is_setter()),
);
exprs.push(
if !self.c.loose && props_cnt == 1 && !self.used_define_enum_props {
ObjectLit {
span: DUMMY_SP,
props: obj_props,
}
.into()
} else {
AssignExpr {
span: DUMMY_SP,
left: obj_ident.clone().into(),
op: op!("="),
right: Box::new(
ObjectLit {
span: DUMMY_SP,
props: obj_props,
}
.into(),
),
}
.into()
},
);
let mut single_cnt_prop = None;
for prop in props.drain(..) {
let span = prop.span();
let ((key, is_compute), value) = match prop {
PropOrSpread::Prop(prop) => match *prop {
Prop::Shorthand(ident) => (
(
if self.c.loose {
ident.clone().into()
} else {
Lit::Str(Str {
span: ident.span,
raw: None,
value: ident.sym.clone(),
})
.into()
},
false,
),
ident.into(),
),
Prop::KeyValue(KeyValueProp { key, value }) => {
(prop_name_to_expr(key, self.c.loose), *value)
}
Prop::Assign(..) => {
unreachable!("assign property in object literal is invalid")
}
prop @ Prop::Getter(GetterProp { .. })
| prop @ Prop::Setter(SetterProp { .. }) => {
self.used_define_enum_props = true;
// getter/setter property name
let gs_prop_name = match prop {
Prop::Getter(..) => Some("get"),
Prop::Setter(..) => Some("set"),
_ => None,
};
let (key, function) = match prop {
Prop::Getter(GetterProp {
span, body, key, ..
}) => (
key,
Box::new(Function {
span,
body,
is_async: false,
is_generator: false,
params: Vec::new(),
..Default::default()
}),
),
Prop::Setter(SetterProp {
span,
body,
param,
key,
..
}) => (
key,
Box::new(Function {
span,
body,
is_async: false,
is_generator: false,
params: vec![(*param).into()],
..Default::default()
}),
),
_ => unreachable!(),
};
// mutator[f]
let mutator_elem = mutator_map
.clone()
.computed_member(prop_name_to_expr(key, false).0);
// mutator[f] = mutator[f] || {}
exprs.push(
AssignExpr {
span,
left: mutator_elem.clone().into(),
op: op!("="),
right: Box::new(
BinExpr {
span,
left: mutator_elem.clone().into(),
op: op!("||"),
right: Box::new(Expr::Object(ObjectLit {
span,
props: Vec::new(),
})),
}
.into(),
),
}
.into(),
);
// mutator[f].get = function(){}
exprs.push(
AssignExpr {
span,
left: mutator_elem
.make_member(quote_ident!(gs_prop_name.unwrap()))
.into(),
op: op!("="),
right: Box::new(
FnExpr {
ident: None,
function,
}
.into(),
),
}
.into(),
);
continue;
// unimplemented!("getter /setter property")
}
Prop::Method(MethodProp { key, function }) => (
prop_name_to_expr(key, self.c.loose),
FnExpr {
ident: None,
function,
}
.into(),
),
},
PropOrSpread::Spread(..) => unimplemented!("computed spread property"),
};
if !self.c.loose && props_cnt == 1 {
single_cnt_prop = Some(
CallExpr {
span,
callee: helper!(define_property),
args: vec![exprs.pop().unwrap().as_arg(), key.as_arg(), value.as_arg()],
..Default::default()
}
.into(),
);
break;
}
exprs.push(if self.c.loose {
let left = if is_compute {
obj_ident.clone().computed_member(key)
} else {
obj_ident.clone().make_member(key.ident().unwrap().into())
};
AssignExpr {
span,
op: op!("="),
left: left.into(),
right: value.into(),
}
.into()
} else {
CallExpr {
span,
callee: helper!(define_property),
args: vec![obj_ident.clone().as_arg(), key.as_arg(), value.as_arg()],
..Default::default()
}
.into()
});
}
if let Some(single_expr) = single_cnt_prop {
*expr = single_expr;
return;
}
self.vars.push(VarDeclarator {
span: *span,
name: obj_ident.clone().into(),
init: None,
definite: false,
});
if self.used_define_enum_props {
self.vars.push(VarDeclarator {
span: DUMMY_SP,
name: mutator_map.clone().into(),
init: Some(
ObjectLit {
span: DUMMY_SP,
props: Vec::new(),
}
.into(),
),
definite: false,
});
exprs.push(
CallExpr {
span: *span,
callee: helper!(define_enumerable_properties),
args: vec![obj_ident.clone().as_arg(), mutator_map.as_arg()],
..Default::default()
}
.into(),
);
}
// Last value
exprs.push(obj_ident.into());
*expr = SeqExpr {
span: DUMMY_SP,
exprs,
}
.into();
};
}
fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem>) {
self.visit_mut_stmt_like(n);
}
fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt>) {
self.visit_mut_stmt_like(n);
}
}
fn is_complex<T: VisitWith<ComplexVisitor>>(node: &T) -> bool {
let mut visitor = ComplexVisitor::default();
node.visit_children_with(&mut visitor);
visitor.found
}
#[derive(Default)]
struct ComplexVisitor {
found: bool,
}
impl Visit for ComplexVisitor {
noop_visit_type!(fail);
fn visit_prop_name(&mut self, pn: &PropName) {
if let PropName::Computed(..) = *pn {
self.found = true
}
}
}
#[swc_trace]
impl ComputedProps {
fn visit_mut_stmt_like<T>(&mut self, stmts: &mut Vec<T>)
where
T: StmtLike + VisitWith<ShouldWork> + VisitMutWith<Self>,
Vec<T>: VisitWith<ShouldWork>,
{
let mut stmts_updated = Vec::with_capacity(stmts.len());
for mut stmt in stmts.drain(..) {
if !contains_computed_expr(&stmt) {
stmts_updated.push(stmt);
continue;
}
let mut folder = Self {
c: self.c,
..Default::default()
};
stmt.visit_mut_with(&mut folder);
// Add variable declaration
// e.g. var ref
if !folder.vars.is_empty() {
stmts_updated.push(T::from(
VarDecl {
kind: VarDeclKind::Var,
decls: folder.vars,
..Default::default()
}
.into(),
));
}
stmts_updated.push(stmt);
}
*stmts = stmts_updated;
}
}
fn prop_name_to_expr(p: PropName, loose: bool) -> (Expr, bool) {
match p {
PropName::Ident(i) => (
if loose {
i.into()
} else {
Lit::Str(Str {
raw: None,
value: i.sym,
span: i.span,
})
.into()
},
false,
),
PropName::Str(s) => (Lit::Str(s).into(), true),
PropName::Num(n) => (Lit::Num(n).into(), true),
PropName::BigInt(b) => (Lit::BigInt(b).into(), true),
PropName::Computed(c) => (*c.expr, true),
}
}
fn contains_computed_expr<N>(node: &N) -> bool
where
N: VisitWith<ShouldWork>,
{
let mut v = ShouldWork { found: false };
node.visit_with(&mut v);
v.found
}
struct ShouldWork {
found: bool,
}
impl Visit for ShouldWork {
noop_visit_type!(fail);
fn visit_prop_name(&mut self, node: &PropName) {
if let PropName::Computed(_) = *node {
self.found = true
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/destructuring.rs | Rust | use std::{iter, mem};
use serde::Deserialize;
use swc_common::{util::take::Take, Span, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_compat_common::impl_visit_mut_fn;
use swc_ecma_transforms_base::{helper, helper_expr, perf::Check};
use swc_ecma_transforms_macros::fast_path;
use swc_ecma_utils::{
alias_ident_for, alias_if_required, has_rest_pat, is_literal, member_expr, private_ident,
prop_name_to_expr, quote_ident, ExprFactory, StmtLike,
};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith, VisitWith,
};
use swc_trace_macro::swc_trace;
/// `@babel/plugin-transform-destructuring`
///
/// # Example
/// ## In
/// ```js
/// let {x, y} = obj;
///
/// let [a, b, ...rest] = arr;
/// ```
/// ## Out
/// ```js
/// let _obj = obj,
/// x = _obj.x,
/// y = _obj.y;
///
/// let _arr = arr,
/// _arr2 = _to_array(_arr),
/// a = _arr2[0],
/// b = _arr2[1],
/// rest = _arr2.slice(2);
/// ```
pub fn destructuring(c: Config) -> impl Pass {
visit_mut_pass(Destructuring { c })
}
struct Destructuring {
c: Config,
}
#[derive(Debug, Default, Clone, Copy, Deserialize)]
pub struct Config {
#[serde(default)]
pub loose: bool,
}
macro_rules! impl_for_for_stmt {
($name:ident, $T:tt) => {
fn $name(&mut self, for_stmt: &mut $T) {
for_stmt.visit_mut_children_with(self);
let (left, stmt) = match &mut for_stmt.left {
ForHead::VarDecl(var_decl) => {
let has_complex = var_decl.decls.iter().any(|d| match d.name {
Pat::Ident(_) => false,
_ => true,
});
if !has_complex {
return;
}
let ref_ident = make_ref_ident_for_for_stmt();
let left = VarDecl {
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: ref_ident.clone().into(),
init: None,
definite: false,
}],
span: var_decl.span,
kind: var_decl.kind,
declare: var_decl.declare,
..Default::default()
}
.into();
// I(kdy1) guess var_decl.len() == 1
let mut decls = var_decl
.decls
.take()
.into_iter()
.map(|decl| VarDeclarator {
init: Some(Box::new(Expr::Ident(ref_ident.clone()))),
..decl
})
.collect::<Vec<_>>();
decls.visit_mut_children_with(self);
// Unpack variables
let stmt: Stmt = VarDecl {
span: var_decl.span(),
kind: VarDeclKind::Let,
decls,
..Default::default()
}
.into();
(left, stmt)
}
ForHead::Pat(pat) => match **pat {
Pat::Ident(..) => {
return;
}
_ => {
let left_ident = make_ref_ident_for_for_stmt();
let left = ForHead::Pat(left_ident.clone().into());
// Unpack variables
let stmt = AssignExpr {
span: DUMMY_SP,
left: pat.take().try_into().unwrap(),
op: op!("="),
right: Box::new(left_ident.into()),
}
.into_stmt();
(left, stmt)
}
},
ForHead::UsingDecl(..) => {
unreachable!("using declaration must be removed by previous pass")
}
};
for_stmt.left = left;
for_stmt.body = Box::new(Stmt::Block(match &mut *for_stmt.body {
Stmt::Block(BlockStmt { span, stmts, ctxt }) => BlockStmt {
span: *span,
stmts: iter::once(stmt).chain(stmts.take()).collect(),
ctxt: *ctxt,
},
body => BlockStmt {
stmts: vec![stmt, body.take()],
..Default::default()
},
}));
}
};
}
fn make_ref_ident_for_for_stmt() -> Ident {
private_ident!("ref")
}
#[swc_trace]
impl AssignFolder {
fn visit_mut_var_decl(&mut self, decls: &mut Vec<VarDeclarator>, decl: VarDeclarator) {
match decl.name {
Pat::Ident(..) => decls.push(decl),
Pat::Rest(..) => unreachable!(
"rest pattern should handled by array pattern handler: {:?}",
decl.name
),
Pat::Array(ArrayPat { elems, .. }) => {
assert!(
decl.init.is_some(),
"destructuring pattern binding requires initializer"
);
let init = decl.init.unwrap();
if is_literal(&init) {
match *init {
Expr::Array(arr)
if !elems.is_empty()
&& (elems.len() == arr.elems.len()
|| (elems.len() < arr.elems.len() && has_rest_pat(&elems))) =>
{
let mut arr_elems = Some(arr.elems.into_iter());
elems.into_iter().for_each(|p| match p {
Some(Pat::Rest(p)) => {
self.visit_mut_var_decl(
decls,
VarDeclarator {
span: p.span(),
name: *p.arg,
init: Some(
ArrayLit {
span: DUMMY_SP,
elems: arr_elems
.take()
.expect("two rest element?")
.collect(),
}
.into(),
),
definite: false,
},
);
}
Some(p) => {
let e = arr_elems
.as_mut()
.expect("pattern after rest element?")
.next()
.unwrap();
self.visit_mut_var_decl(
decls,
VarDeclarator {
span: p.span(),
init: e.map(|e| {
debug_assert_eq!(e.spread, None);
e.expr
}),
name: p,
definite: false,
},
)
}
None => {
arr_elems
.as_mut()
.expect("pattern after rest element?")
.next();
}
});
return;
}
_ => {}
}
}
// Make ref var if required
let ref_ident = make_ref_ident_for_array(
self.c,
if self.exporting {
&mut self.vars
} else {
decls
},
Some(init),
Some(if has_rest_pat(&elems) {
usize::MAX
} else {
elems.len()
}),
);
for (i, elem) in elems.into_iter().enumerate() {
let elem: Pat = match elem {
Some(elem) => elem,
None => continue,
};
let var_decl = match elem {
Pat::Rest(RestPat {
dot3_token, arg, ..
}) => VarDeclarator {
span: dot3_token,
name: *arg,
init: Some(
CallExpr {
span: DUMMY_SP,
callee: ref_ident
.clone()
.make_member(quote_ident!("slice"))
.as_callee(),
args: vec![Number {
value: i as f64,
span: dot3_token,
raw: None,
}
.as_arg()],
..Default::default()
}
.into(),
),
definite: false,
},
_ => VarDeclarator {
span: elem.span(),
// This might be pattern.
// So we fold it again.
name: elem,
init: Some(make_ref_idx_expr(&ref_ident, i).into()),
definite: false,
},
};
let mut var_decls = vec![var_decl];
var_decls.visit_mut_with(self);
decls.extend(var_decls);
}
}
Pat::Object(ObjectPat { span, props, .. }) if props.is_empty() => {
// We should convert
//
// var {} = null;
//
// to
//
// var _ref = null;
// _object_destructuring_empty(_ref);
//
let expr = helper_expr!(object_destructuring_empty).as_call(
DUMMY_SP,
vec![decl
.init
.expect("destructuring must be initialized")
.as_arg()],
);
let var_decl = VarDeclarator {
span: DUMMY_SP,
name: private_ident!(span, "ref").into(),
init: Some(Box::new(expr)),
definite: false,
};
decls.push(var_decl);
}
Pat::Object(ObjectPat { props, .. }) => {
assert!(
decl.init.is_some(),
"destructuring pattern binding requires initializer"
);
if props.len() == 1 {
if let ObjectPatProp::Assign(p @ AssignPatProp { value: None, .. }) = &props[0]
{
decls.push(VarDeclarator {
span: decl.span,
name: p.key.clone().into(),
init: Some(decl.init.unwrap().make_member(p.key.clone().into()).into()),
definite: false,
});
return;
}
}
let can_be_null = can_be_null(decl.init.as_ref().unwrap());
let ref_decls = if self.exporting {
&mut self.vars
} else {
&mut *decls
};
let ref_ident = make_ref_ident(self.c, ref_decls, decl.init);
let ref_ident = if can_be_null {
let init = ref_ident.into();
make_ref_ident(self.c, ref_decls, Some(init))
} else {
ref_ident
};
for prop in props {
let prop_span = prop.span();
match prop {
ObjectPatProp::KeyValue(KeyValuePatProp { key, value }) => {
let computed = matches!(key, PropName::Computed(..));
let var_decl = VarDeclarator {
span: prop_span,
name: *value,
init: Some(Box::new(make_ref_prop_expr(
&ref_ident,
Box::new(prop_name_to_expr(key)),
computed,
))),
definite: false,
};
let mut var_decls = vec![var_decl];
var_decls.visit_mut_with(self);
decls.extend(var_decls);
}
ObjectPatProp::Assign(AssignPatProp { key, value, .. }) => {
let computed = false;
match value {
Some(value) => {
let ref_ident = make_ref_ident(
self.c,
decls,
Some(Box::new(make_ref_prop_expr(
&ref_ident,
key.clone().into(),
computed,
))),
);
let var_decl = VarDeclarator {
span: prop_span,
name: key.clone().into(),
init: Some(Box::new(make_cond_expr(ref_ident, value))),
definite: false,
};
let mut var_decls = vec![var_decl];
var_decls.visit_mut_with(self);
decls.extend(var_decls);
}
None => {
let var_decl = VarDeclarator {
span: prop_span,
name: key.clone().into(),
init: Some(Box::new(make_ref_prop_expr(
&ref_ident,
key.clone().into(),
computed,
))),
definite: false,
};
let mut var_decls = vec![var_decl];
var_decls.visit_mut_with(self);
decls.extend(var_decls);
}
}
}
ObjectPatProp::Rest(..) => unreachable!(
"Object rest pattern should be removed by es2018::object_rest_spread \
pass"
),
}
}
}
Pat::Assign(AssignPat {
span,
left,
right: def_value,
..
}) => {
let init = if let Some(init) = decl.init {
let tmp_ident = match &*init {
Expr::Ident(ref i) if i.ctxt != SyntaxContext::empty() => i.clone(),
_ => {
let tmp_ident = private_ident!(span, "tmp");
decls.push(VarDeclarator {
span: DUMMY_SP,
name: tmp_ident.clone().into(),
init: Some(init),
definite: false,
});
tmp_ident
}
};
// tmp === void 0 ? def_value : tmp
Some(Box::new(make_cond_expr(tmp_ident, def_value)))
} else {
Some(def_value)
};
let var_decl = VarDeclarator {
span,
name: *left,
init,
definite: false,
};
let mut var_decls = vec![var_decl];
var_decls.visit_mut_with(self);
decls.extend(var_decls);
}
_ => unimplemented!("Pattern {:?}", decl),
}
}
}
#[swc_trace]
#[fast_path(DestructuringVisitor)]
impl VisitMut for Destructuring {
noop_visit_mut_type!(fail);
impl_for_for_stmt!(visit_mut_for_in_stmt, ForInStmt);
impl_for_for_stmt!(visit_mut_for_of_stmt, ForOfStmt);
impl_visit_mut_fn!();
fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem>) {
self.visit_mut_stmt_like(n);
}
fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt>) {
self.visit_mut_stmt_like(n);
}
}
#[swc_trace]
impl Destructuring {
fn visit_mut_fn_like(
&mut self,
ps: &mut Vec<Param>,
body: &mut BlockStmt,
) -> (Vec<Param>, BlockStmt) {
let mut params = Vec::new();
let mut decls = Vec::new();
for param in ps.drain(..) {
let span = param.span();
match param.pat {
Pat::Ident(..) => params.push(param),
Pat::Array(..) | Pat::Object(..) | Pat::Assign(..) => {
let ref_ident = private_ident!(span, "ref");
params.push(Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: ref_ident.clone().into(),
});
decls.push(VarDeclarator {
span,
name: param.pat,
init: Some(ref_ident.into()),
definite: false,
})
}
Pat::Rest(..) | Pat::Expr(..) => params.push(param),
Pat::Invalid(..) => {}
}
}
let stmts = if decls.is_empty() {
body.stmts.take()
} else {
let mut stmt: Stmt = VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Let,
decls,
declare: false,
..Default::default()
}
.into();
stmt.visit_mut_children_with(self);
iter::once(stmt).chain(body.stmts.take()).collect()
};
(
params,
BlockStmt {
stmts,
..body.take()
},
)
}
}
struct AssignFolder {
c: Config,
exporting: bool,
vars: Vec<VarDeclarator>,
/// Used like `.take().is_some()`.
ignore_return_value: Option<()>,
}
impl AssignFolder {
pub fn handle_assign_pat(
&mut self,
span: Span,
mut pat: AssignPat,
right: &mut Box<Expr>,
) -> Expr {
let ref_ident = make_ref_ident(self.c, &mut self.vars, None);
let mut exprs = vec![Box::new(
AssignExpr {
span,
left: ref_ident.clone().into(),
op: op!("="),
right: right.take(),
}
.into(),
)];
let mut assign_cond_expr: Expr = AssignExpr {
span,
left: pat.left.take().try_into().unwrap(),
op: op!("="),
right: Box::new(make_cond_expr(ref_ident, pat.right.take())),
}
.into();
assign_cond_expr.visit_mut_with(self);
exprs.push(Box::new(assign_cond_expr));
SeqExpr {
span: DUMMY_SP,
exprs,
}
.into()
}
}
#[swc_trace]
#[fast_path(DestructuringVisitor)]
impl VisitMut for AssignFolder {
noop_visit_mut_type!(fail);
fn visit_mut_export_decl(&mut self, decl: &mut ExportDecl) {
let old = self.exporting;
self.exporting = true;
decl.visit_mut_children_with(self);
self.exporting = old;
}
fn visit_mut_function(&mut self, f: &mut Function) {
let exporting = mem::replace(&mut self.exporting, false);
f.visit_mut_children_with(self);
self.exporting = exporting;
}
fn visit_mut_class(&mut self, f: &mut Class) {
let exporting = mem::replace(&mut self.exporting, false);
f.visit_mut_children_with(self);
self.exporting = exporting;
}
fn visit_mut_object_lit(&mut self, f: &mut ObjectLit) {
let exporting = mem::replace(&mut self.exporting, false);
f.visit_mut_children_with(self);
self.exporting = exporting;
}
fn visit_mut_arrow_expr(&mut self, f: &mut ArrowExpr) {
let exporting = mem::replace(&mut self.exporting, false);
f.visit_mut_children_with(self);
self.exporting = exporting;
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
let ignore_return_value = self.ignore_return_value.take().is_some();
match expr {
// Handle iife
Expr::Fn(..) | Expr::Object(..) => {
expr.visit_mut_with(&mut Destructuring { c: self.c })
}
_ => expr.visit_mut_children_with(self),
};
if let Expr::Assign(AssignExpr {
span,
left: AssignTarget::Pat(pat),
op: op!("="),
right,
}) = expr
{
match pat {
// Pat::Expr(pat_expr) => {
// *expr = Expr::Assign(AssignExpr {
// span: *span,
// left: pat_expr.take().try_into().unwrap(),
// op: op!("="),
// right: right.take(),
// });
// }
AssignTargetPat::Array(ArrayPat { elems, .. }) => {
let mut exprs = Vec::with_capacity(elems.len() + 1);
if is_literal(right) && ignore_return_value {
match &mut **right {
Expr::Array(arr)
if elems.len() == arr.elems.len()
|| (elems.len() < arr.elems.len() && has_rest_pat(elems)) =>
{
let mut arr_elems = Some(arr.elems.take().into_iter());
elems.iter_mut().for_each(|p| match p {
Some(Pat::Rest(p)) => {
exprs.push(
AssignExpr {
span: p.span(),
left: p.arg.take().try_into().unwrap(),
op: op!("="),
right: Box::new(
ArrayLit {
span: DUMMY_SP,
elems: arr_elems
.take()
.expect("two rest element?")
.collect(),
}
.into(),
),
}
.into(),
);
}
Some(p) => {
let e = arr_elems
.as_mut()
.expect("pattern after rest element?")
.next()
.and_then(|v| v);
let mut right = e
.map(|e| {
debug_assert_eq!(e.spread, None);
e.expr
})
.unwrap_or_else(|| Expr::undefined(p.span()));
let p = p.take();
let mut expr = if let Pat::Assign(pat) = p {
self.handle_assign_pat(*span, pat, &mut right)
} else {
AssignExpr {
span: p.span(),
left: p.try_into().unwrap(),
op: op!("="),
right,
}
.into()
};
self.visit_mut_expr(&mut expr);
exprs.push(Box::new(expr));
}
None => {
arr_elems
.as_mut()
.expect("pattern after rest element?")
.next();
}
});
*expr = SeqExpr { span: *span, exprs }.into();
return;
}
_ => {}
}
}
// initialized by first element of sequence expression
let ref_ident = make_ref_ident_for_array(
self.c,
&mut self.vars,
None,
Some(if has_rest_pat(elems) {
usize::MAX
} else {
elems.len()
}),
);
exprs.push(
AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: ref_ident.clone().into(),
right: if self.c.loose {
right.take()
} else {
match &mut **right {
Expr::Ident(Ident { sym, .. }) if &**sym == "arguments" => {
Box::new(
CallExpr {
span: DUMMY_SP,
callee: member_expr!(
Default::default(),
Default::default(),
Array.prototype.slice.call
)
.as_callee(),
args: vec![right.take().as_arg()],
..Default::default()
}
.into(),
)
}
Expr::Array(..) => right.take(),
_ => {
// if left has rest then need `_to_array`
// else `_sliced_to_array`
if elems
.iter()
.any(|elem| matches!(elem, Some(Pat::Rest(..))))
{
Box::new(
CallExpr {
span: DUMMY_SP,
callee: helper!(to_array),
args: vec![right.take().as_arg()],
..Default::default()
}
.into(),
)
} else {
Box::new(
CallExpr {
span: DUMMY_SP,
callee: helper!(sliced_to_array),
args: vec![
right.take().as_arg(),
elems.len().as_arg(),
],
..Default::default()
}
.into(),
)
}
}
}
},
}
.into(),
);
for (i, elem) in elems.iter_mut().enumerate() {
let elem = match elem {
Some(elem) => elem,
None => continue,
};
let elem_span = elem.span();
match elem {
Pat::Assign(AssignPat {
span, left, right, ..
}) => {
// initialized by sequence expression.
let assign_ref_ident = make_ref_ident(self.c, &mut self.vars, None);
exprs.push(
AssignExpr {
span: DUMMY_SP,
left: assign_ref_ident.clone().into(),
op: op!("="),
right: ref_ident.clone().computed_member(i as f64).into(),
}
.into(),
);
let mut assign_expr: Expr = AssignExpr {
span: *span,
left: left.take().try_into().unwrap(),
op: op!("="),
right: Box::new(make_cond_expr(assign_ref_ident, right.take())),
}
.into();
assign_expr.visit_mut_with(self);
exprs.push(Box::new(assign_expr));
}
Pat::Rest(RestPat { arg, .. }) => {
let mut assign_expr: Expr = AssignExpr {
span: elem_span,
op: op!("="),
left: arg.take().try_into().unwrap(),
right: CallExpr {
span: DUMMY_SP,
callee: ref_ident
.clone()
.make_member(quote_ident!("slice"))
.as_callee(),
args: vec![(i as f64).as_arg()],
..Default::default()
}
.into(),
}
.into();
assign_expr.visit_mut_with(self);
exprs.push(Box::new(assign_expr));
}
_ => {
let mut assign_expr: Expr = AssignExpr {
span: elem_span,
op: op!("="),
left: elem.take().try_into().unwrap(),
right: make_ref_idx_expr(&ref_ident, i).into(),
}
.into();
assign_expr.visit_mut_with(self);
exprs.push(Box::new(assign_expr))
}
}
}
// last one should be `ref`
exprs.push(ref_ident.into());
*expr = SeqExpr {
span: DUMMY_SP,
exprs,
}
.into()
}
AssignTargetPat::Object(ObjectPat { props, .. }) if props.is_empty() => {
let mut right = right.take();
right.visit_mut_with(self);
*expr = helper_expr!(object_destructuring_empty)
.as_call(DUMMY_SP, vec![right.as_arg()]);
}
AssignTargetPat::Object(ObjectPat { span, props, .. }) => {
if props.len() == 1 {
if let ObjectPatProp::Assign(p @ AssignPatProp { value: None, .. }) =
&props[0]
{
*expr = AssignExpr {
span: *span,
op: op!("="),
left: p.key.clone().into(),
right: right.take().make_member(p.key.clone().into()).into(),
}
.into();
return;
}
}
let ref_ident = make_ref_ident(self.c, &mut self.vars, None);
let mut exprs = vec![Box::new(Expr::Assign(AssignExpr {
span: *span,
left: ref_ident.clone().into(),
op: op!("="),
right: right.take(),
}))];
for prop in props {
let span = prop.span();
match prop {
ObjectPatProp::KeyValue(KeyValuePatProp { key, value }) => {
let computed = matches!(key, PropName::Computed(..));
let mut right = Box::new(make_ref_prop_expr(
&ref_ident,
Box::new(prop_name_to_expr(key.take())),
computed,
));
let value = value.take();
let mut expr = if let Pat::Assign(pat) = *value {
self.handle_assign_pat(span, pat, &mut right)
} else {
AssignExpr {
span,
left: value.try_into().unwrap(),
op: op!("="),
right,
}
.into()
};
expr.visit_mut_with(self);
exprs.push(Box::new(expr));
}
ObjectPatProp::Assign(AssignPatProp { key, value, .. }) => {
let computed = false;
match value {
Some(value) => {
let prop_ident =
make_ref_ident(self.c, &mut self.vars, None);
exprs.push(
AssignExpr {
span,
left: prop_ident.clone().into(),
op: op!("="),
right: Box::new(make_ref_prop_expr(
&ref_ident,
key.clone().into(),
computed,
)),
}
.into(),
);
exprs.push(
AssignExpr {
span,
left: key.clone().into(),
op: op!("="),
right: Box::new(make_cond_expr(
prop_ident,
value.take(),
)),
}
.into(),
);
}
None => {
exprs.push(
AssignExpr {
span,
left: key.clone().into(),
op: op!("="),
right: Box::new(make_ref_prop_expr(
&ref_ident,
key.clone().into(),
computed,
)),
}
.into(),
);
}
}
}
ObjectPatProp::Rest(_) => unreachable!(
"object rest pattern should be removed by \
es2018::object_rest_spread pass"
),
}
}
// Last one should be object itself.
exprs.push(ref_ident.into());
*expr = SeqExpr {
span: DUMMY_SP,
exprs,
}
.into();
}
AssignTargetPat::Invalid(..) => unreachable!(),
}
};
}
fn visit_mut_stmt(&mut self, s: &mut Stmt) {
match s {
Stmt::Expr(e) => {
self.ignore_return_value = Some(());
e.visit_mut_with(self);
assert_eq!(self.ignore_return_value, None);
}
_ => s.visit_mut_children_with(self),
};
}
fn visit_mut_var_declarators(&mut self, declarators: &mut Vec<VarDeclarator>) {
declarators.visit_mut_children_with(self);
let is_complex = declarators
.iter()
.any(|d| !matches!(d.name, Pat::Ident(..)));
if !is_complex {
return;
}
let mut decls = Vec::with_capacity(declarators.len());
for decl in declarators.drain(..) {
self.visit_mut_var_decl(&mut decls, decl);
}
*declarators = decls;
}
fn visit_mut_var_decl(&mut self, var_decl: &mut VarDecl) {
var_decl.decls.visit_mut_with(self);
if var_decl.kind == VarDeclKind::Const {
var_decl.decls.iter_mut().for_each(|v| {
if v.init.is_none() {
v.init = Some(Expr::undefined(DUMMY_SP));
}
})
}
}
}
#[swc_trace]
impl Destructuring {
fn visit_mut_stmt_like<T>(&mut self, stmts: &mut Vec<T>)
where
Vec<T>: VisitMutWith<Self>,
T: StmtLike + VisitMutWith<AssignFolder>,
{
stmts.visit_mut_children_with(self);
let mut stmts_updated = Vec::with_capacity(stmts.len());
for stmt in stmts.drain(..) {
let mut folder = AssignFolder {
c: self.c,
exporting: false,
vars: Vec::new(),
ignore_return_value: None,
};
match stmt.try_into_stmt() {
Err(mut item) => {
item.visit_mut_with(&mut folder);
// Add variable declaration
// e.g. var ref
if !folder.vars.is_empty() {
stmts_updated.push(T::from(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: folder.vars,
..Default::default()
}
.into(),
));
}
stmts_updated.push(item);
}
Ok(mut stmt) => {
stmt.visit_mut_with(&mut folder);
// Add variable declaration
// e.g. var ref
if !folder.vars.is_empty() {
stmts_updated.push(T::from(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: folder.vars,
..Default::default()
}
.into(),
));
}
stmts_updated.push(T::from(stmt));
}
}
}
*stmts = stmts_updated;
}
}
fn make_ref_idx_expr(ref_ident: &Ident, i: usize) -> MemberExpr {
ref_ident.clone().computed_member(i as f64)
}
fn make_ref_ident(c: Config, decls: &mut Vec<VarDeclarator>, init: Option<Box<Expr>>) -> Ident {
make_ref_ident_for_array(c, decls, init, None)
}
#[tracing::instrument(level = "info", skip_all)]
fn make_ref_ident_for_array(
c: Config,
decls: &mut Vec<VarDeclarator>,
mut init: Option<Box<Expr>>,
elem_cnt: Option<usize>,
) -> Ident {
if elem_cnt.is_none() {
if let Some(e) = init {
match *e {
Expr::Ident(i) => return i,
_ => init = Some(e),
}
}
}
let span = init.span();
let (ref_ident, aliased) = if c.loose {
if let Some(ref init) = init {
alias_if_required(init, "ref")
} else {
(private_ident!(span, "ref"), true)
}
} else if let Some(ref init) = init {
(alias_ident_for(init, "ref"), true)
} else {
(private_ident!(span, "ref"), true)
};
if aliased {
decls.push(VarDeclarator {
span,
name: ref_ident.clone().into(),
init: init.map(|v| {
if c.loose || matches!(*v, Expr::Array(..)) {
v
} else {
match elem_cnt {
None => v,
Some(std::usize::MAX) => Box::new(
CallExpr {
span: DUMMY_SP,
callee: helper!(to_array),
args: vec![v.as_arg()],
..Default::default()
}
.into(),
),
Some(value) => Box::new(
CallExpr {
span: DUMMY_SP,
callee: helper!(sliced_to_array),
args: vec![v.as_arg(), value.as_arg()],
..Default::default()
}
.into(),
),
}
}
}),
definite: false,
});
}
ref_ident
}
fn make_ref_prop_expr(ref_ident: &Ident, prop: Box<Expr>, mut computed: bool) -> Expr {
computed |= !matches!(*prop, Expr::Ident(..));
MemberExpr {
span: DUMMY_SP,
obj: Box::new(ref_ident.clone().into()),
prop: if computed {
MemberProp::Computed(ComputedPropName {
span: DUMMY_SP,
expr: prop,
})
} else {
MemberProp::Ident(prop.ident().unwrap().into())
},
}
.into()
}
/// Creates `tmp === void 0 ? def_value : tmp`
fn make_cond_expr(tmp: Ident, def_value: Box<Expr>) -> Expr {
CondExpr {
span: DUMMY_SP,
test: BinExpr {
span: DUMMY_SP,
left: Box::new(Expr::Ident(tmp.clone())),
op: op!("==="),
right: Box::new(Expr::Unary(UnaryExpr {
span: DUMMY_SP,
op: op!("void"),
arg: 0.0.into(),
})),
}
.into(),
cons: def_value,
alt: tmp.into(),
}
.into()
}
fn can_be_null(e: &Expr) -> bool {
match *e {
Expr::Lit(Lit::Null(..))
| Expr::This(..)
| Expr::Ident(..)
| Expr::PrivateName(..)
| Expr::Member(..)
| Expr::SuperProp(..)
| Expr::Call(..)
| Expr::OptChain(..)
| Expr::New(..)
| Expr::Yield(..)
| Expr::Await(..)
| Expr::MetaProp(..) => true,
Expr::Lit(..) => false,
Expr::Array(..)
| Expr::Arrow(..)
| Expr::Object(..)
| Expr::Fn(..)
| Expr::Class(..)
| Expr::Tpl(..) => false,
Expr::TaggedTpl(..) => true,
Expr::Paren(ParenExpr { ref expr, .. }) => can_be_null(expr),
Expr::Seq(SeqExpr { ref exprs, .. }) => {
exprs.last().map(|e| can_be_null(e)).unwrap_or(true)
}
Expr::Assign(AssignExpr { ref right, .. }) => can_be_null(right),
Expr::Cond(CondExpr {
ref cons, ref alt, ..
}) => can_be_null(cons) || can_be_null(alt),
Expr::Unary(..) | Expr::Update(..) | Expr::Bin(..) => true,
Expr::JSXMember(..)
| Expr::JSXNamespacedName(..)
| Expr::JSXEmpty(..)
| Expr::JSXElement(..)
| Expr::JSXFragment(..) => unreachable!("destructuring jsx"),
Expr::TsNonNull(..) => false,
Expr::TsAs(TsAsExpr { ref expr, .. })
| Expr::TsTypeAssertion(TsTypeAssertion { ref expr, .. })
| Expr::TsConstAssertion(TsConstAssertion { ref expr, .. })
| Expr::TsInstantiation(TsInstantiation { ref expr, .. })
| Expr::TsSatisfies(TsSatisfiesExpr { ref expr, .. }) => can_be_null(expr),
Expr::Invalid(..) => unreachable!(),
}
}
#[derive(Default)]
struct DestructuringVisitor {
found: bool,
}
impl Visit for DestructuringVisitor {
noop_visit_type!(fail);
fn visit_assign_target_pat(&mut self, _: &AssignTargetPat) {
self.found = true;
}
fn visit_pat(&mut self, node: &Pat) {
node.visit_children_with(self);
match *node {
Pat::Ident(..) => {}
_ => self.found = true,
}
}
}
impl Check for DestructuringVisitor {
fn should_handle(&self) -> bool {
self.found
}
}
#[cfg(test)]
mod tests {
use swc_ecma_transforms_testing::test;
use super::*;
test!(
::swc_ecma_parser::Syntax::default(),
|_| destructuring(Default::default()),
nested_for_of,
r#"
for (const [k1, v1] of Object.entries(o)){
for (const [k2, v2] of Object.entries(o)){
console.log(k1, v1, k2, v2);
}
}
"#
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/duplicate_keys.rs | Rust | use rustc_hash::FxHashSet;
use swc_atoms::Atom;
use swc_common::Spanned;
use swc_ecma_ast::*;
use swc_ecma_transforms_base::perf::Parallel;
use swc_ecma_utils::quote_str;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
pub fn duplicate_keys() -> impl Pass {
visit_mut_pass(DuplicateKeys)
}
struct DuplicateKeys;
impl Parallel for DuplicateKeys {
fn merge(&mut self, _: Self) {}
fn create(&self) -> Self {
Self
}
}
#[swc_trace]
impl VisitMut for DuplicateKeys {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Expr::Object(ObjectLit { props, .. }) = expr {
let mut folder = PropFolder::default();
props.visit_mut_with(&mut folder);
}
}
}
#[derive(Default)]
struct PropFolder {
getter_props: FxHashSet<Atom>,
setter_props: FxHashSet<Atom>,
}
#[swc_trace]
impl VisitMut for PropFolder {
noop_visit_mut_type!(fail);
/// Noop
fn visit_mut_expr(&mut self, _: &mut Expr) {}
fn visit_mut_prop(&mut self, prop: &mut Prop) {
match prop {
Prop::Shorthand(ident) => {
//
if !self.getter_props.insert(ident.sym.clone())
|| !self.setter_props.insert(ident.sym.clone())
{
*prop = Prop::KeyValue(KeyValueProp {
key: PropName::Computed(ComputedPropName {
span: ident.span,
expr: quote_str!(ident.sym.clone()).into(),
}),
value: ident.clone().into(),
})
}
}
Prop::Assign(..) => {}
Prop::Getter(..) => prop.visit_mut_children_with(&mut PropNameFolder {
props: &mut self.getter_props,
}),
Prop::Setter(..) => prop.visit_mut_children_with(&mut PropNameFolder {
props: &mut self.setter_props,
}),
_ => {
prop.visit_mut_children_with(&mut PropNameFolder {
props: &mut self.getter_props,
});
prop.visit_mut_children_with(&mut PropNameFolder {
props: &mut self.setter_props,
})
}
}
}
}
struct PropNameFolder<'a> {
props: &'a mut FxHashSet<Atom>,
}
#[swc_trace]
impl VisitMut for PropNameFolder<'_> {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, _: &mut Expr) {}
fn visit_mut_prop_name(&mut self, name: &mut PropName) {
let span = name.span();
match name {
PropName::Ident(ident) => {
if !self.props.insert(ident.sym.clone()) {
*name = PropName::Computed(ComputedPropName {
span,
expr: Lit::Str(Str {
span,
raw: None,
value: ident.sym.clone(),
})
.into(),
})
}
}
PropName::Str(s) => {
if !self.props.insert(s.value.clone()) {
*name = PropName::Computed(ComputedPropName {
span: s.span,
expr: s.clone().into(),
})
}
}
PropName::Computed(ComputedPropName { expr, .. }) => {
// Computed property might collide
if let Expr::Lit(Lit::Str(Str { ref value, .. })) = &**expr {
self.props.insert(value.clone());
}
}
_ => {}
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/for_of.rs | Rust | use std::mem::take;
use serde::Deserialize;
use swc_common::{util::take::Take, Mark, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{
helper,
perf::{ParExplode, Parallel},
};
use swc_ecma_transforms_macros::parallel;
use swc_ecma_utils::{
alias_if_required, member_expr, prepend_stmt, private_ident, quote_ident, ExprFactory,
};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
/// `@babel/plugin-transform-for-of`
///
/// ## In
///
/// ```js
/// for (var i of foo) {}
/// ```
///
/// ## Out
///
/// ```js
/// var _iteratorNormalCompletion = true;
/// var _didIteratorError = false;
/// var _iteratorError = undefined;
///
/// try {
/// for (var _iterator = foo[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
/// var i = _step.value;
/// }
/// } catch (err) {
/// _didIteratorError = true;
/// _iteratorError = err;
/// } finally {
/// try {
/// if (!_iteratorNormalCompletion && _iterator.return != null) {
/// _iterator.return();
/// }
/// } finally {
/// if (_didIteratorError) {
/// throw _iteratorError;
/// }
/// }
/// }
/// ```
pub fn for_of(c: Config) -> impl Pass {
visit_mut_pass(ForOf {
c,
top_level_vars: Default::default(),
})
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
pub loose: bool,
pub assume_array: bool,
}
struct ForOf {
c: Config,
///```js
/// var _iteratorNormalCompletion = true;
/// var _didIteratorError = false;
/// var _iteratorError = undefined;
/// ```
top_level_vars: Vec<VarDeclarator>,
}
#[swc_trace]
impl ForOf {
fn fold_for_stmt(
&mut self,
label: Option<Ident>,
ForOfStmt {
span,
left,
right,
body,
..
}: ForOfStmt,
) -> Stmt {
if right.is_array() || (self.c.assume_array && !self.c.loose) {
// Convert to normal for loop if rhs is array
//
// babel's output:
//
// for(var _i = 0, _t = t; _i < _t.length; _i++){
// let o = _t[_i];
// const t = o;
// }
let (arr, aliased) = alias_if_required(&right, "_iter");
let i = private_ident!("_i");
let test = Some(
BinExpr {
span: DUMMY_SP,
left: Box::new(i.clone().into()),
op: op!("<"),
right: arr.clone().make_member(quote_ident!("length")).into(),
}
.into(),
);
let update = Some(
UpdateExpr {
span: DUMMY_SP,
prefix: false,
op: op!("++"),
arg: Box::new(i.clone().into()),
}
.into(),
);
let mut decls = Vec::with_capacity(2);
decls.push(VarDeclarator {
span: DUMMY_SP,
name: i.clone().into(),
init: Some(0.into()),
definite: false,
});
if aliased {
decls.push(VarDeclarator {
span: DUMMY_SP,
name: arr.clone().into(),
init: Some(right),
definite: false,
});
}
let mut body = match *body {
Stmt::Block(b) => b,
_ => BlockStmt {
span: DUMMY_SP,
stmts: vec![*body],
..Default::default()
},
};
match left {
ForHead::VarDecl(var) => {
assert_eq!(
var.decls.len(),
1,
"Variable declarator of for of loop cannot contain multiple entries"
);
prepend_stmt(
&mut body.stmts,
VarDecl {
span: DUMMY_SP,
kind: var.kind,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: var.decls.into_iter().next().unwrap().name,
init: Some(arr.computed_member(i).into()),
definite: false,
}],
..Default::default()
}
.into(),
)
}
ForHead::Pat(pat) => prepend_stmt(
&mut body.stmts,
AssignExpr {
span: DUMMY_SP,
left: pat.try_into().unwrap(),
op: op!("="),
right: arr.computed_member(i).into(),
}
.into_stmt(),
),
ForHead::UsingDecl(..) => {
unreachable!("using declaration must be removed by previous pass")
}
}
let stmt = ForStmt {
span,
init: Some(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Let,
declare: false,
decls,
..Default::default()
}
.into(),
),
test,
update,
body: Box::new(Stmt::Block(body)),
}
.into();
return match label {
Some(label) => LabeledStmt {
span,
label,
body: Box::new(stmt),
}
.into(),
_ => stmt,
};
}
// Loose mode
if self.c.loose {
let iterator = private_ident!("_iterator");
let step = private_ident!("_step");
let decls = vec![
VarDeclarator {
span: DUMMY_SP,
name: iterator.clone().into(),
init: Some(Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
callee: helper!(create_for_of_iterator_helper_loose),
args: vec![right.as_arg()],
..Default::default()
}))),
definite: Default::default(),
},
VarDeclarator {
span: DUMMY_SP,
name: step.clone().into(),
init: None,
definite: Default::default(),
},
];
let mut body = match *body {
Stmt::Block(b) => b,
_ => BlockStmt {
stmts: vec![*body],
..Default::default()
},
};
match left {
ForHead::VarDecl(var) => {
assert_eq!(
var.decls.len(),
1,
"Variable declarator of for of loop cannot contain multiple entries"
);
prepend_stmt(
&mut body.stmts,
VarDecl {
kind: var.kind,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: var.decls.into_iter().next().unwrap().name,
init: Some(step.clone().make_member(quote_ident!("value")).into()),
definite: false,
}],
..Default::default()
}
.into(),
)
}
ForHead::Pat(pat) => prepend_stmt(
&mut body.stmts,
AssignExpr {
span: DUMMY_SP,
left: pat.try_into().unwrap(),
op: op!("="),
right: step.clone().make_member(quote_ident!("value")).into(),
}
.into_stmt(),
),
ForHead::UsingDecl(..) => {
unreachable!("using declaration must be removed by previous pass")
}
}
// !(_step = _iterator()).done;
let test = UnaryExpr {
span: DUMMY_SP,
op: op!("!"),
arg: AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: step.into(),
right: CallExpr {
span: DUMMY_SP,
callee: iterator.as_callee(),
args: Vec::new(),
..Default::default()
}
.into(),
}
.make_member(quote_ident!("done"))
.into(),
}
.into();
let stmt = ForStmt {
span,
init: Some(
VarDecl {
kind: VarDeclKind::Var,
decls,
..Default::default()
}
.into(),
),
test: Some(test),
update: None,
body: Box::new(Stmt::Block(body)),
}
.into();
return match label {
Some(label) => LabeledStmt {
span,
label,
body: Box::new(stmt),
}
.into(),
_ => stmt,
};
}
let var_span = left.span();
let var_ctxt = SyntaxContext::empty().apply_mark(Mark::fresh(Mark::root()));
let mut body = match *body {
Stmt::Block(block) => block,
body => BlockStmt {
span: DUMMY_SP,
stmts: vec![body],
..Default::default()
},
};
let step = quote_ident!(var_ctxt, var_span, "_step");
let step_value = step.clone().make_member(quote_ident!("value"));
body.stmts.insert(
0,
match left {
ForHead::VarDecl(mut var) => {
assert_eq!(var.decls.len(), 1);
VarDecl {
span: var.span,
kind: var.kind,
decls: vec![VarDeclarator {
init: Some(step_value.into()),
..var.decls.pop().unwrap()
}],
declare: false,
..Default::default()
}
.into()
}
ForHead::Pat(pat) => AssignExpr {
span: DUMMY_SP,
left: pat.try_into().unwrap(),
op: op!("="),
right: step_value.into(),
}
.into_stmt(),
ForHead::UsingDecl(..) => {
unreachable!("using declaration must be removed by previous pass")
}
},
);
let iterator = quote_ident!(var_ctxt, var_span, "_iterator");
// `_iterator.return`
let iterator_return = iterator.clone().make_member(quote_ident!("return")).into();
let normal_completion_ident =
Ident::new("_iteratorNormalCompletion".into(), var_span, var_ctxt);
self.top_level_vars.push(VarDeclarator {
span: DUMMY_SP,
name: normal_completion_ident.clone().into(),
init: Some(true.into()),
definite: false,
});
let error_flag_ident = Ident::new("_didIteratorError".into(), var_span, var_ctxt);
self.top_level_vars.push(VarDeclarator {
span: DUMMY_SP,
name: error_flag_ident.clone().into(),
init: Some(false.into()),
definite: false,
});
let error_ident = Ident::new("_iteratorError".into(), var_span, var_ctxt);
self.top_level_vars.push(VarDeclarator {
span: DUMMY_SP,
name: error_ident.clone().into(),
init: Some(Ident::new_no_ctxt("undefined".into(), DUMMY_SP).into()),
definite: false,
});
let for_stmt = ForStmt {
span,
init: Some(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: false,
decls: vec![
VarDeclarator {
span: DUMMY_SP,
name: iterator.clone().into(),
init: Some(Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
callee: right
.computed_member(member_expr!(
Default::default(),
Default::default(),
Symbol.iterator
))
.as_callee(),
args: Vec::new(),
..Default::default()
}))),
definite: false,
},
VarDeclarator {
span: DUMMY_SP,
name: step.clone().into(),
init: None,
definite: false,
},
],
..Default::default()
}
.into(),
),
// !(_iteratorNormalCompletion = (_step = _iterator.next()).done)
test: Some(
UnaryExpr {
span: DUMMY_SP,
op: op!("!"),
arg: {
let step_expr: Expr = AssignExpr {
span: DUMMY_SP,
left: step.into(),
op: op!("="),
// `_iterator.next()`
right: Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
// `_iterator.next`
callee: iterator.make_member(quote_ident!("next")).as_callee(),
args: Vec::new(),
..Default::default()
})),
}
.into();
Box::new(
AssignExpr {
span: DUMMY_SP,
left: normal_completion_ident.clone().into(),
op: op!("="),
right: step_expr.make_member(quote_ident!("done")).into(),
}
.into(),
)
},
}
.into(),
),
// `_iteratorNormalCompletion = true`
update: Some(
AssignExpr {
span: DUMMY_SP,
left: normal_completion_ident.clone().into(),
op: op!("="),
right: true.into(),
}
.into(),
),
body: Box::new(body.into()),
}
.into();
let for_stmt = match label {
Some(label) => LabeledStmt {
span,
label,
body: Box::new(for_stmt),
}
.into(),
None => for_stmt,
};
TryStmt {
span: DUMMY_SP,
block: BlockStmt {
span: DUMMY_SP,
stmts: vec![for_stmt],
..Default::default()
},
handler: Some(CatchClause {
span: DUMMY_SP,
param: Some(quote_ident!("err").into()),
// _didIteratorError = true;
// _iteratorError = err;
body: BlockStmt {
stmts: vec![
// _didIteratorError = true;
AssignExpr {
span: DUMMY_SP,
left: error_flag_ident.clone().into(),
op: op!("="),
right: true.into(),
}
.into_stmt(),
// _iteratorError = err;
AssignExpr {
span: DUMMY_SP,
left: error_ident.clone().into(),
op: op!("="),
right: Box::new(Expr::Ident(quote_ident!("err").into())),
}
.into_stmt(),
],
..Default::default()
},
}),
finalizer: Some(BlockStmt {
stmts: vec![make_finally_block(
iterator_return,
&normal_completion_ident,
error_flag_ident,
error_ident,
)],
..Default::default()
}),
}
.into()
}
}
/// ```js
/// try {
/// if (!_iteratorNormalCompletion && _iterator.return != null) {
/// _iterator.return();
/// }
/// } finally {
/// if (_didIteratorError) {
/// throw _iteratorError;
/// }
/// }
/// ```
#[tracing::instrument(level = "info", skip_all)]
fn make_finally_block(
iterator_return: Box<Expr>,
normal_completion_ident: &Ident,
error_flag_ident: Ident,
error_ident: Ident,
) -> Stmt {
TryStmt {
span: DUMMY_SP,
block: BlockStmt {
span: DUMMY_SP,
stmts: vec![
// if (!_iteratorNormalCompletion && _iterator.return !=
// null) {
// _iterator.return();
// }
Stmt::If(IfStmt {
span: DUMMY_SP,
test: Box::new(Expr::Bin(BinExpr {
span: DUMMY_SP,
left: Box::new(Expr::Unary(UnaryExpr {
span: DUMMY_SP,
op: op!("!"),
arg: Box::new(Expr::Ident(normal_completion_ident.clone())),
})),
op: op!("&&"),
right: Box::new(Expr::Bin(BinExpr {
span: DUMMY_SP,
left: iterator_return.clone(),
op: op!("!="),
right: Null { span: DUMMY_SP }.into(),
})),
})),
cons: Box::new(Stmt::Block(BlockStmt {
span: DUMMY_SP,
stmts: vec![CallExpr {
span: DUMMY_SP,
callee: iterator_return.as_callee(),
args: Vec::new(),
..Default::default()
}
.into_stmt()],
..Default::default()
})),
alt: None,
}),
],
..Default::default()
},
handler: None,
finalizer: Some(BlockStmt {
stmts: vec![
// if (_didIteratorError) {
// throw _iteratorError;
// }
Stmt::If(IfStmt {
span: DUMMY_SP,
test: Box::new(Expr::Ident(error_flag_ident)),
cons: Box::new(Stmt::Block(BlockStmt {
stmts: vec![Stmt::Throw(ThrowStmt {
span: DUMMY_SP,
arg: Box::new(Expr::Ident(error_ident)),
})],
..Default::default()
})),
alt: None,
}),
],
..Default::default()
}),
}
.into()
}
impl Parallel for ForOf {
fn create(&self) -> Self {
ForOf {
c: self.c,
top_level_vars: Default::default(),
}
}
fn merge(&mut self, other: Self) {
self.top_level_vars.extend(other.top_level_vars);
}
}
#[swc_trace]
impl ParExplode for ForOf {
fn after_one_stmt(&mut self, stmts: &mut Vec<Stmt>) {
// Add variable declaration
// e.g. var ref
if !self.top_level_vars.is_empty() {
stmts.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: take(&mut self.top_level_vars),
declare: false,
..Default::default()
}
.into(),
);
}
}
fn after_one_module_item(&mut self, stmts: &mut Vec<ModuleItem>) {
// Add variable declaration
// e.g. var ref
if !self.top_level_vars.is_empty() {
stmts.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: take(&mut self.top_level_vars),
declare: false,
..Default::default()
}
.into(),
);
}
}
}
#[swc_trace]
#[parallel(explode)]
impl VisitMut for ForOf {
noop_visit_mut_type!(fail);
fn visit_mut_stmt(&mut self, s: &mut Stmt) {
match s {
Stmt::Labeled(LabeledStmt { label, body, .. }) => {
// Handle label
match &mut **body {
Stmt::ForOf(stmt) => {
stmt.visit_mut_children_with(self);
*s = self.fold_for_stmt(Some(label.clone()), stmt.take());
}
_ => {
body.visit_mut_with(self);
}
}
}
Stmt::ForOf(stmt) => {
stmt.visit_mut_children_with(self);
*s = self.fold_for_stmt(None, stmt.take())
}
_ => s.visit_mut_children_with(self),
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/function_name.rs | Rust | use swc_common::{util::take::Take, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::perf::Parallel;
use swc_ecma_utils::{private_ident, IdentUsageFinder};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
/// `@babel/plugin-transform-function-name`
///
/// # Example
/// ## In
/// ```js
/// var number = function (x) {
/// return x;
/// };
/// var Foo = (class {});
/// ```
/// ## Out
/// ```js
/// var number = function number(x) {
/// return x;
/// }
/// var Foo = (class Foo {});
/// ```
pub fn function_name() -> impl Pass {
visit_mut_pass(FnName)
}
#[derive(Clone, Copy)]
struct FnName;
impl Parallel for FnName {
fn create(&self) -> Self {
*self
}
fn merge(&mut self, _: Self) {}
}
struct Rename {
name: Option<Ident>,
}
/// This function makes a new private identifier if required.
fn prepare(i: Ident) -> Ident {
if i.is_reserved() || i.is_reserved_in_strict_mode(true) || i.is_reserved_in_strict_bind() {
return private_ident!(i.span, format!("_{}", i.sym));
}
private_ident!(i.span, i.sym)
}
#[swc_trace]
impl VisitMut for FnName {
noop_visit_mut_type!(fail);
fn visit_mut_assign_expr(&mut self, expr: &mut AssignExpr) {
expr.visit_mut_children_with(self);
if expr.op != op!("=") {
return;
}
if let Some(ident) = expr.left.as_ident_mut() {
let mut folder = Rename {
name: Some(Ident::from(&*ident)),
};
expr.right.visit_mut_with(&mut folder);
}
}
fn visit_mut_key_value_prop(&mut self, p: &mut KeyValueProp) {
p.visit_mut_children_with(self);
if let Expr::Fn(expr @ FnExpr { ident: None, .. }) = &mut *p.value {
//
p.value = if let PropName::Ident(ref i) = p.key {
FnExpr {
ident: Some(prepare(i.clone().into())),
..expr.take()
}
.into()
} else {
expr.take().into()
};
};
}
fn visit_mut_var_declarator(&mut self, decl: &mut VarDeclarator) {
decl.visit_mut_children_with(self);
if let Pat::Ident(ref mut ident) = decl.name {
let mut folder = Rename {
name: Some(prepare(Ident::from(&*ident))),
};
decl.init.visit_mut_with(&mut folder);
}
}
}
macro_rules! impl_for {
($name:ident, $T:tt) => {
fn $name(&mut self, node: &mut $T) {
match node.ident {
Some(..) => return,
None => {
//
let name = match self.name.take() {
None => {
node.ident = None;
return;
}
Some(name) => name,
};
// If function's body references the name of variable, we just skip the
// function
if IdentUsageFinder::find(&name.to_id(), &*node) {
// self.name = Some(name);
node.ident = None;
} else {
node.ident = Some(private_ident!(DUMMY_SP, name.sym));
}
}
}
}
};
}
macro_rules! noop {
($name:ident, $T:tt) => {
/// Don't recurse.
fn $name(&mut self, _: &mut $T) {}
};
}
impl VisitMut for Rename {
noop_visit_mut_type!(fail);
impl_for!(visit_mut_fn_expr, FnExpr);
impl_for!(visit_mut_class_expr, ClassExpr);
noop!(visit_mut_object_lit, ObjectLit);
noop!(visit_mut_array_lit, ArrayLit);
noop!(visit_mut_call_expr, CallExpr);
noop!(visit_mut_new_expr, NewExpr);
noop!(visit_mut_bin_expr, BinExpr);
noop!(visit_mut_unary_expr, UnaryExpr);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/generator.rs | Rust | use std::{
cell::{RefCell, RefMut},
iter::once,
mem::take,
rc::Rc,
};
use is_macro::Is;
use swc_atoms::Atom;
use swc_common::{
comments::Comments, util::take::Take, BytePos, EqIgnoreSpan, Mark, Span, Spanned,
SyntaxContext, DUMMY_SP,
};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::helper;
use swc_ecma_utils::{
function::FnEnvHoister, private_ident, prop_name_to_expr_value, quote_ident, ExprFactory,
};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith, VisitWith,
};
use tracing::debug;
/// Generator based on tsc generator at https://github.com/microsoft/TypeScript/blob/162224763681465b417274383317ca9a0a573835/src/compiler/transformers/generators.ts
pub fn generator<C>(unresolved_mark: Mark, _comments: C) -> impl Pass
where
C: Comments,
{
visit_mut_pass(Wrapper {
unresolved_ctxt: SyntaxContext::empty().apply_mark(unresolved_mark),
})
}
/// Instead of saving state, we just create another instance of [Generator].
struct Wrapper {
unresolved_ctxt: SyntaxContext,
}
macro_rules! dev_span {
($($tt:tt)*) => {{
if cfg!(debug_assertions) {
Some(tracing::span!(tracing::Level::ERROR, $($tt)*).entered())
} else {
None
}
}};
}
impl VisitMut for Wrapper {
noop_visit_mut_type!(fail);
fn visit_mut_function(&mut self, f: &mut Function) {
f.visit_mut_children_with(self);
if f.is_generator {
let mut v = Generator::default();
let mut hoister = FnEnvHoister::new(self.unresolved_ctxt);
hoister.disable_super();
hoister.disable_this();
f.visit_mut_children_with(&mut hoister);
v.transform_and_emit_stmts(f.body.as_mut().unwrap().stmts.take(), 0);
f.is_generator = false;
let mut stmts = v.build_stmts();
stmts.visit_mut_with(&mut InvalidToLit {
map: v.label_exprs.as_deref(),
});
let inner_fn = Box::new(Function {
span: DUMMY_SP,
params: vec![Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: Pat::Ident(v.state.clone().into()),
}],
decorators: Default::default(),
body: Some(BlockStmt {
stmts,
..Default::default()
}),
is_generator: false,
is_async: false,
..Default::default()
});
let generator_object = CallExpr {
span: DUMMY_SP,
callee: helper!(ts, ts_generator),
args: vec![
ThisExpr { span: DUMMY_SP }.as_arg(),
FnExpr {
ident: None,
function: inner_fn,
}
.as_arg(),
],
..Default::default()
}
.into();
let mut stmts = Vec::new();
if !v.hoisted_vars.is_empty() {
stmts.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: Default::default(),
decls: v.hoisted_vars.take(),
..Default::default()
}
.into(),
)
}
let vars = hoister.to_decl();
if !vars.is_empty() {
stmts.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: Default::default(),
decls: vars,
..Default::default()
}
.into(),
)
}
stmts.extend(v.hoisted_fns.into_iter().map(Decl::Fn).map(Stmt::Decl));
stmts.push(
ReturnStmt {
span: DUMMY_SP,
arg: Some(generator_object),
}
.into(),
);
f.body.as_mut().unwrap().stmts = stmts;
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Label(isize);
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum OpCode {
/// No operation, used to force a new case in the state machine
Nop,
/// A regular javascript statement
Statement,
/// An assignment
Assign,
/// A break instruction used to jump to a label
Break,
/// A break instruction used to jump to a label if a condition evaluates to
/// true
BreakWhenTrue,
/// A break instruction used to jump to a label if a condition evaluates to
/// false
BreakWhenFalse,
/// A completion instruction for the `yield` keyword
Yield,
/// A completion instruction for the `yield*` keyword (not implemented, but
/// reserved for future use)
YieldStar,
/// A completion instruction for the `return` keyword
Return,
/// A completion instruction for the `throw` keyword
Throw,
/// Marks the end of a `finally` block
Endfinally,
}
#[derive(Debug, Is, Clone)]
enum OpArgs {
Label(Label),
LabelExpr(Label, Box<Expr>),
Stmt(Box<Stmt>),
OptExpr(Option<Box<Expr>>),
PatAndExpr(AssignTarget, Box<Expr>),
}
/// whether a generated code block is opening or closing at the current
/// operation for a FunctionBuilder
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum BlockAction {
Open,
Close,
}
/// the kind for a generated code block in a FunctionBuilder
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum CodeBlockKind {
Exception,
With,
Switch,
Loop,
Labeled,
}
/// the state for a generated code exception block
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
enum ExceptionBlockState {
Try,
Catch,
Finally,
Done,
}
/// A generated code block
#[derive(Debug)]
enum CodeBlock {
Exception(ExceptionBlock),
Labeled(LabeledBlock),
Switch(SwitchBlock),
Loop(LoopBlock),
With(WithBlock),
}
impl CodeBlock {
fn is_script(&self) -> bool {
match self {
Self::Exception(..) => false,
Self::Labeled(b) => b.is_script,
Self::Switch(b) => b.is_script,
Self::Loop(b) => b.is_script,
Self::With(..) => false,
}
}
fn label_text(&self) -> Option<Atom> {
match self {
Self::Labeled(s) => Some(s.label_text.clone()),
_ => None,
}
}
fn break_label(&self) -> Option<Label> {
Some(match self {
Self::Labeled(b) => b.break_label,
Self::Switch(b) => b.break_label,
Self::Loop(b) => b.break_label,
_ => return None,
})
}
fn continue_label(&self) -> Option<Label> {
Some(match self {
Self::Loop(b) => b.continue_label,
_ => return None,
})
}
}
/// a generated exception block, used for 'try' statements
#[derive(Debug)]
struct ExceptionBlock {
state: ExceptionBlockState,
start_label: Label,
catch_variable: Option<Ident>,
catch_label: Option<Label>,
finally_label: Option<Label>,
end_label: Label,
}
/// A generated code that tracks the target for 'break' statements in a
/// LabeledStatement.
#[derive(Debug)]
struct LabeledBlock {
label_text: Atom,
is_script: bool,
break_label: Label,
}
/// a generated block that tracks the target for 'break' statements in a
/// 'switch' statement
#[derive(Debug)]
struct SwitchBlock {
is_script: bool,
break_label: Label,
}
/// a generated block that tracks the targets for 'break' and 'continue'
/// statements, used for iteration statements
#[derive(Debug)]
struct LoopBlock {
continue_label: Label,
is_script: bool,
break_label: Label,
}
/// a generated block associated with a 'with' statement
#[allow(unused)]
#[derive(Debug)]
struct WithBlock {
expression: Ident,
start_label: Label,
end_label: Label,
}
#[allow(dead_code)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
enum Instruction {
Next = 0,
Throw = 1,
Return = 2,
Break = 3,
Yield = 4,
YieldStar = 5,
Catch = 6,
Endfinally = 7,
}
impl Instruction {
// fn name(self) -> Option<&'static str> {
// match self {
// Instruction::Return => Some("return"),
// Instruction::Break => Some("break"),
// Instruction::Yield => Some("yield"),
// Instruction::YieldStar => Some("yield*"),
// Instruction::Endfinally => Some("endfinally"),
// _ => None,
// }
// }
}
struct Generator {
in_statement_containing_yield: bool,
blocks: Option<Vec<Ptr<CodeBlock>>>,
block_offsets: Option<Vec<usize>>,
block_actions: Option<Vec<BlockAction>>,
/// Index to `blocks`
block_stack: Option<Vec<Ptr<CodeBlock>>>,
label_offsets: Option<Vec<i32>>,
label_exprs: Option<Vec<Vec<Loc>>>,
next_label_id: usize,
operations: Option<Vec<OpCode>>,
operation_args: Option<Vec<Option<OpArgs>>>,
operation_locs: Option<Vec<Span>>,
state: Ident,
block_index: usize,
label_number: usize,
label_numbers: Option<Vec<Vec<usize>>>,
last_operation_was_abrupt: bool,
last_operation_was_completion: bool,
clauses: Option<Vec<SwitchCase>>,
stmts: Option<Vec<Stmt>>,
/// Index to `blocks`
exception_block_stack: Option<Vec<Ptr<CodeBlock>>>,
/// Index to `blocks`
current_exception_block: Option<Ptr<CodeBlock>>,
/// Index to `blocks`
with_block_stack: Option<Vec<Ptr<CodeBlock>>>,
hoisted_vars: Vec<VarDeclarator>,
hoisted_fns: Vec<FnDecl>,
}
type Ptr<T> = Rc<RefCell<T>>;
impl Default for Generator {
fn default() -> Self {
Self {
in_statement_containing_yield: Default::default(),
blocks: Default::default(),
block_offsets: Default::default(),
block_actions: Default::default(),
block_stack: Default::default(),
label_offsets: Default::default(),
label_exprs: Default::default(),
next_label_id: 1,
operations: Default::default(),
operation_args: Default::default(),
operation_locs: Default::default(),
state: private_ident!("_state"),
block_index: Default::default(),
label_number: Default::default(),
label_numbers: Default::default(),
last_operation_was_abrupt: Default::default(),
last_operation_was_completion: Default::default(),
clauses: Default::default(),
stmts: Default::default(),
exception_block_stack: Default::default(),
current_exception_block: Default::default(),
with_block_stack: Default::default(),
hoisted_vars: Default::default(),
hoisted_fns: Default::default(),
}
}
}
impl VisitMut for Generator {
noop_visit_mut_type!(fail);
fn visit_mut_arrow_expr(&mut self, e: &mut ArrowExpr) {
e.params.visit_mut_with(self);
}
fn visit_mut_function(&mut self, e: &mut Function) {
e.params.visit_mut_with(self);
}
fn visit_mut_getter_prop(&mut self, _: &mut GetterProp) {}
fn visit_mut_setter_prop(&mut self, e: &mut SetterProp) {
e.param.visit_mut_with(self);
}
fn visit_mut_expr(&mut self, e: &mut Expr) {
match e {
Expr::Yield(node) => {
// [source]
// x = yield a();
//
// [intermediate]
// .yield resumeLabel, (a())
// .mark resumeLabel
// x = %sent%;
let resume_label = self.define_label();
node.arg.visit_mut_with(self);
if node.delegate {
let arg = node
.arg
.take()
.map(|e| CallExpr {
span: DUMMY_SP,
callee: helper!(ts, ts_values),
args: vec![e.as_arg()],
..Default::default()
})
.map(Expr::from)
.map(Box::new);
self.emit_yield_star(arg, Some(node.span))
} else {
self.emit_yield(node.arg.take(), Some(node.span));
}
self.mark_label(resume_label);
*e = *self.create_generator_resume(Some(node.span));
}
Expr::Cond(node) => {
// [source]
// x = a() ? yield : b();
//
// [intermediate]
// .local _a
// .brfalse whenFalseLabel, (a())
// .yield resumeLabel
// .mark resumeLabel
// _a = %sent%;
// .br resultLabel
// .mark whenFalseLabel
// _a = b();
// .mark resultLabel
// x = _a;
// We only need to perform a specific transformation if a
// `yield` expression exists in either the
// `whenTrue` or `whenFalse` branches. A `yield`
// in the condition will be handled by the normal visitor.
if contains_yield(&node.cons) || contains_yield(&node.alt) {
let when_false_label = self.define_label();
let result_label = self.define_label();
let result_local = self.declare_local(None);
node.test.visit_mut_with(self);
let cond_span = node.test.span();
self.emit_break_when_false(when_false_label, node.test.take(), Some(cond_span));
let cons_span = node.cons.span();
node.cons.visit_mut_with(self);
self.emit_assignment(
result_local.clone().into(),
node.cons.take(),
Some(cons_span),
);
self.emit_break(result_label, None);
self.mark_label(when_false_label);
let alt_span = node.cons.span();
node.alt.visit_mut_with(self);
self.emit_assignment(
result_local.clone().into(),
node.alt.take(),
Some(alt_span),
);
self.mark_label(result_label);
*e = result_local.into();
} else {
node.visit_mut_with(self);
}
}
Expr::Bin(node) => {
if node.op == op!("**") {
todo!("right-associative binary expression")
} else {
let new = self.visit_left_associative_bin_expr(node);
if let Some(new) = new {
*e = new;
}
}
}
Expr::Seq(node) => {
// // flattened version of `visitCommaExpression`
let mut pending_expressions = Vec::new();
for mut elem in node.exprs.take() {
if let Expr::Seq(mut elem) = *elem {
elem.visit_mut_with(self);
pending_expressions.extend(elem.exprs.take());
} else {
if contains_yield(&elem) && !pending_expressions.is_empty() {
self.emit_worker(
OpCode::Statement,
Some(OpArgs::Stmt(Box::new(
ExprStmt {
span: DUMMY_SP,
expr: if pending_expressions.len() == 1 {
pending_expressions.remove(0)
} else {
SeqExpr {
span: DUMMY_SP,
exprs: pending_expressions.take(),
}
.into()
},
}
.into(),
))),
None,
);
}
elem.visit_mut_with(self);
pending_expressions.push(elem);
}
}
if pending_expressions.len() == 1 {
*e = *pending_expressions.remove(0);
} else {
node.exprs = pending_expressions;
}
}
Expr::Member(MemberExpr {
obj,
prop: MemberProp::Computed(prop),
..
}) => {
if contains_yield(prop) {
// [source]
// a = x[yield];
//
// [intermediate]
// .local _a
// _a = x;
// .yield resumeLabel
// .mark resumeLabel
// a = _a[%sent%]
*obj = self.cache_expression(obj.take()).into();
prop.visit_mut_with(self);
return;
}
e.visit_mut_children_with(self);
}
Expr::Assign(node) if contains_yield(&node.right) => {
match node.left.as_mut_simple() {
Some(SimpleAssignTarget::Member(left)) => {
match &mut left.prop {
MemberProp::Ident(..) | MemberProp::PrivateName(..) => {
// a.b = yield;
//
// [intermediate]
// .local _a
// _a = a;
// .yield resumeLabel
// .mark resumeLabel
// _a.b = %sent%;
left.obj.visit_mut_with(self);
let obj = self.cache_expression(left.obj.take());
left.obj = obj.into();
}
MemberProp::Computed(prop) => {
// [source]
// a[b] = yield;
//
// [intermediate]
// .local _a, _b
// _a = a;
// _b = b;
// .yield resumeLabel
// .mark resumeLabel
// _a[_b] = %sent%;
let prop_span = prop.span;
left.obj.visit_mut_with(self);
let obj = self.cache_expression(left.obj.take());
prop.visit_mut_with(self);
let prop = self.cache_expression(prop.expr.take());
left.obj = obj.into();
left.prop = MemberProp::Computed(ComputedPropName {
span: prop_span,
expr: prop.into(),
});
}
}
// [source]
}
_ => {
node.left.visit_mut_with(self);
}
}
if node.op != op!("=") {
let left_of_right =
self.cache_expression(node.left.take().expect_simple().into());
node.right.visit_mut_with(self);
*e = AssignExpr {
span: node.right.span(),
op: node.op,
left: left_of_right.into(),
right: node.right.take(),
}
.into();
} else {
node.right.visit_mut_with(self);
}
}
Expr::Object(node) if node.props.iter().any(contains_yield) => {
// [source]
// o = {
// a: 1,
// b: yield,
// c: 2
// };
//
// [intermediate]
// .local _a
// _a = {
// a: 1
// };
// .yield resumeLabel
// .mark resumeLabel
// o = (_a.b = %sent%,
// _a.c = 2,
// _a);
let num_initial_properties = self.count_initial_nodes_without_yield(&node.props);
let mut temp = self.declare_local(None);
node.props
.iter_mut()
.take(num_initial_properties)
.for_each(|p| {
p.visit_mut_with(self);
});
self.emit_assignment(
temp.clone().into(),
ObjectLit {
span: DUMMY_SP,
props: node
.props
.iter_mut()
.take(num_initial_properties)
.map(|v| v.take())
.collect(),
}
.into(),
None,
);
let mut expressions = node
.props
.iter_mut()
.skip(num_initial_properties)
.map(|v| v.take())
.fold(Vec::<CompiledProp>::new(), |mut props, p| {
match p {
PropOrSpread::Spread(_) => {
unreachable!("spread should be removed before applying generator")
}
PropOrSpread::Prop(p) => match *p {
Prop::Getter(p) => {
if let Some(CompiledProp::Accessor(g, _)) =
props.iter_mut().find(|prev| match prev {
CompiledProp::Accessor(_, Some(s)) => {
s.key.eq_ignore_span(&p.key)
}
_ => false,
})
{
*g = Some(p);
} else {
props.push(CompiledProp::Accessor(Some(p), None))
}
}
Prop::Setter(p) => {
if let Some(CompiledProp::Accessor(_, s)) =
props.iter_mut().find(|prev| match prev {
CompiledProp::Accessor(Some(prev), _) => {
prev.key.eq_ignore_span(&p.key)
}
_ => false,
})
{
*s = Some(p);
} else {
props.push(CompiledProp::Accessor(None, Some(p)))
}
}
p => {
props.push(CompiledProp::Prop(p));
}
},
}
props
})
.into_iter()
.fold(Vec::new(), |exprs, property| {
self.reduce_property(exprs, property, &mut temp)
});
expressions.push(temp.into());
*e = *Expr::from_exprs(expressions);
}
Expr::Array(node) => {
*e = self.visit_elements(&mut node.elems, None, None);
}
_ => {
e.visit_mut_children_with(self);
}
}
}
fn visit_mut_call_expr(&mut self, node: &mut CallExpr) {
if !node.callee.is_import() && node.args.iter().any(contains_yield) {
// [source]
// a.b(1, yield, 2);
//
// [intermediate]
// .local _a, _b, _c
// _b = (_a = a).b;
// _c = [1];
// .yield resumeLabel
// .mark resumeLabel
// _b.apply(_a, _c.concat([%sent%, 2]));
node.callee.visit_mut_with(self);
let (target, this_arg) =
self.create_call_binding(node.callee.take().expect_expr(), false);
let callee = self.cache_expression(target);
let mut args = node.args.take().into_iter().map(Some).collect::<Vec<_>>();
let arg = self.visit_elements(&mut args, None, None);
let apply = callee.make_member(quote_ident!("apply"));
*node = CallExpr {
span: node.span,
callee: apply.as_callee(),
args: once(this_arg.as_arg()).chain(once(arg.as_arg())).collect(),
..Default::default()
};
return;
}
node.visit_mut_children_with(self);
}
fn visit_mut_new_expr(&mut self, node: &mut NewExpr) {
if contains_yield(&node.args) {
// [source]
// new a.b(1, yield, 2);
//
// [intermediate]
// .local _a, _b, _c
// _b = (_a = a.b).bind;
// _c = [1];
// .yield resumeLabel
// .mark resumeLabel
// new (_b.apply(_a, _c.concat([%sent%, 2])));
node.callee.visit_mut_with(self);
let (target, this_arg) = self.create_call_binding(node.callee.take(), true);
let callee = self.cache_expression(target.make_member(quote_ident!("bind")).into());
let mut arg = if let Some(args) = node.args.take() {
let mut args = args.into_iter().map(Some).collect::<Vec<_>>();
Some(self.visit_elements(
&mut args,
Some(ExprOrSpread {
spread: None,
expr: Expr::undefined(DUMMY_SP),
}),
None,
))
} else {
None
};
let apply = callee.apply(
node.span,
this_arg,
arg.take().map(|v| v.as_arg()).into_iter().collect(),
);
*node = NewExpr {
span: node.span,
callee: Box::new(apply),
args: None,
..Default::default()
};
return;
}
node.visit_mut_children_with(self);
}
fn visit_mut_for_stmt(&mut self, node: &mut ForStmt) {
if self.in_statement_containing_yield {
self.begin_script_loop_block();
}
if let Some(VarDeclOrExpr::VarDecl(initializer)) = &mut node.init {
for variable in initializer.decls.iter_mut() {
self.hoist_variable_declaration(&Ident::from(variable.name.as_ident().unwrap()));
}
let variables = self.get_initialized_variables(initializer);
let mut exprs = variables
.into_iter()
.filter_map(|v| self.transform_initialized_variable(v.take()))
.map(Expr::from)
.map(Box::new)
.collect::<Vec<_>>();
node.init = if exprs.is_empty() {
None
} else {
Some(VarDeclOrExpr::Expr(if exprs.len() == 1 {
exprs.remove(0)
} else {
SeqExpr {
span: DUMMY_SP,
exprs,
}
.into()
}))
};
node.test.visit_mut_with(self);
node.update.visit_mut_with(self);
node.body.visit_mut_with(self);
} else {
node.visit_mut_children_with(self);
}
if self.in_statement_containing_yield {
self.end_loop_block();
}
}
fn visit_mut_do_while_stmt(&mut self, node: &mut DoWhileStmt) {
if self.in_statement_containing_yield {
self.begin_script_loop_block();
node.visit_mut_children_with(self);
self.end_loop_block();
} else {
node.visit_mut_children_with(self);
}
}
fn visit_mut_while_stmt(&mut self, node: &mut WhileStmt) {
if self.in_statement_containing_yield {
self.begin_script_loop_block();
node.visit_mut_children_with(self);
self.end_loop_block();
} else {
node.visit_mut_children_with(self);
}
}
fn visit_mut_return_stmt(&mut self, node: &mut ReturnStmt) {
node.arg.visit_mut_with(self);
*node = self.create_inline_return(node.arg.take(), Some(node.span));
}
fn visit_mut_switch_stmt(&mut self, node: &mut SwitchStmt) {
if self.in_statement_containing_yield {
self.begin_script_switch_block();
}
node.visit_mut_children_with(self);
if self.in_statement_containing_yield {
self.end_switch_block();
}
}
fn visit_mut_labeled_stmt(&mut self, node: &mut LabeledStmt) {
if self.in_statement_containing_yield {
self.begin_script_labeled_block(node.label.sym.clone());
}
node.visit_mut_children_with(self);
if self.in_statement_containing_yield {
self.end_labeled_block();
}
}
fn visit_mut_for_in_stmt(&mut self, node: &mut ForInStmt) {
// [source]
// for (var x in a) {
// /*body*/
// }
//
// [intermediate]
// .local x
// .loop
// for (x in a) {
// /*body*/
// }
// .endloop
if self.in_statement_containing_yield {
self.begin_script_loop_block();
}
if let ForHead::VarDecl(initializer) = &mut node.left {
for variable in &initializer.decls {
self.hoist_variable_declaration(&Ident::from(variable.name.as_ident().unwrap()));
}
node.right.visit_mut_with(self);
node.body.visit_mut_with(self);
} else {
node.visit_mut_children_with(self);
}
if self.in_statement_containing_yield {
self.end_loop_block();
}
}
#[tracing::instrument(skip_all)]
fn visit_mut_stmt(&mut self, node: &mut Stmt) {
match node {
Stmt::Break(b) => {
if self.in_statement_containing_yield {
let label = self.find_break_target(b.label.as_ref().map(|l| l.sym.clone()));
if label.0 > 0 {
*node = self.create_inline_break(label, Some(b.span)).into();
return;
}
}
node.visit_mut_children_with(self);
}
Stmt::Continue(s) => {
if self.in_statement_containing_yield {
let label = self.find_continue_target(s.label.as_ref().map(|l| l.sym.clone()));
if label.0 > 0 {
*node = self.create_inline_break(label, Some(s.span)).into();
return;
}
}
node.visit_mut_children_with(self);
}
Stmt::Decl(Decl::Var(v)) => {
if contains_yield(&*v) {
self.transform_and_emit_var_decl_list(v.take());
node.take();
return;
}
// // Do not hoist custom prologues.
// if (getEmitFlags(node) & EmitFlags.CustomPrologue) {
// return node;
// }
for decl in v.decls.iter() {
self.hoist_variable_declaration(&Ident::from(decl.name.as_ident().unwrap()));
}
let variables = self.get_initialized_variables(v);
if variables.is_empty() {
node.take();
return;
}
let mut exprs = variables
.into_iter()
.filter_map(|v| self.transform_initialized_variable(v.take()))
.map(Expr::from)
.map(Box::new)
.collect::<Vec<_>>();
if exprs.is_empty() {
node.take();
return;
}
*node = ExprStmt {
span: v.span,
expr: if exprs.len() == 1 {
exprs.remove(0)
} else {
SeqExpr {
span: DUMMY_SP,
exprs,
}
.into()
},
}
.into();
}
Stmt::Decl(Decl::Fn(f)) => {
self.hoisted_fns.push(f.take());
node.take();
}
_ => {
node.visit_mut_children_with(self);
}
}
}
}
enum CompiledProp {
Prop(Prop),
Accessor(Option<GetterProp>, Option<SetterProp>),
}
impl Generator {
fn visit_elements(
&mut self,
elements: &mut [Option<ExprOrSpread>],
mut leading_element: Option<ExprOrSpread>,
_loc: Option<Span>,
) -> Expr {
// [source]
// ar = [1, yield, 2];
//
// [intermediate]
// .local _a
// _a = [1];
// .yield resumeLabel
// .mark resumeLabel
// ar = _a.concat([%sent%, 2]);
let num_initial_elements = self.count_initial_nodes_without_yield(elements);
let mut temp = None;
if num_initial_elements > 0 {
temp = Some(self.declare_local(None));
elements[0..num_initial_elements]
.iter_mut()
.for_each(|e| e.visit_mut_with(self));
self.emit_assignment(
temp.clone().unwrap().into(),
ArrayLit {
span: DUMMY_SP,
elems: leading_element
.take()
.into_iter()
.map(Some)
.chain(
elements
.iter_mut()
.take(num_initial_elements)
.map(|e| e.take()),
)
.collect(),
}
.into(),
None,
);
}
let expressions = elements
.iter_mut()
.skip(num_initial_elements)
.map(|v| v.take())
.fold(Vec::new(), |exprs, element| {
self.reduce_element(exprs, element, &mut leading_element, &mut temp)
});
if let Some(temp) = temp {
CallExpr {
span: DUMMY_SP,
callee: temp.make_member(quote_ident!("concat")).as_callee(),
args: vec![ExprOrSpread {
spread: None,
expr: Box::new(Expr::Array(ArrayLit {
span: DUMMY_SP,
elems: expressions,
})),
}],
..Default::default()
}
.into()
} else {
ArrayLit {
span: DUMMY_SP,
elems: leading_element
.take()
.into_iter()
.map(Some)
.chain(expressions)
.collect(),
}
.into()
}
}
fn reduce_element(
&mut self,
mut expressions: Vec<Option<ExprOrSpread>>,
mut element: Option<ExprOrSpread>,
leading_element: &mut Option<ExprOrSpread>,
temp: &mut Option<Ident>,
) -> Vec<Option<ExprOrSpread>> {
if contains_yield(&element) && !expressions.is_empty() {
let has_assigned_temp = temp.is_some();
if temp.is_none() {
*temp = Some(self.declare_local(None));
}
self.emit_assignment(
temp.clone().unwrap().into(),
if has_assigned_temp {
CallExpr {
span: DUMMY_SP,
callee: temp
.clone()
.unwrap()
.make_member(quote_ident!("concat"))
.as_callee(),
args: vec![Box::new(Expr::Array(ArrayLit {
span: DUMMY_SP,
elems: expressions.take(),
}))
.as_arg()],
..Default::default()
}
.into()
} else {
Box::new(
ArrayLit {
span: DUMMY_SP,
elems: leading_element
.take()
.into_iter()
.map(Some)
.chain(expressions.take())
.collect(),
}
.into(),
)
},
None,
);
*leading_element = None;
}
element.visit_mut_with(self);
if element.is_some() {
expressions.push(element);
}
expressions
}
fn reduce_property(
&mut self,
mut expressions: Vec<Box<Expr>>,
property: CompiledProp,
temp: &mut Ident,
) -> Vec<Box<Expr>> {
if match &property {
CompiledProp::Prop(p) => contains_yield(p),
CompiledProp::Accessor(g, s) => {
g.as_ref().map_or(false, contains_yield) || s.as_ref().map_or(false, contains_yield)
}
} && !expressions.is_empty()
{
self.emit_stmt(
ExprStmt {
span: DUMMY_SP,
expr: Expr::from_exprs(expressions.take()),
}
.into(),
);
}
let mut expression: Expr = match property {
CompiledProp::Prop(p) => match p {
Prop::Shorthand(p) => AssignExpr {
span: p.span,
op: op!("="),
left: MemberExpr {
span: DUMMY_SP,
obj: temp.clone().into(),
prop: MemberProp::Ident(p.clone().into()),
}
.into(),
right: p.into(),
}
.into(),
Prop::KeyValue(p) => AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: MemberExpr {
span: DUMMY_SP,
obj: temp.clone().into(),
prop: p.key.into(),
}
.into(),
right: p.value,
}
.into(),
Prop::Assign(_) => {
unreachable!("assignment property be removed before generator pass")
}
Prop::Getter(_) | Prop::Setter(_) => {
unreachable!("getter/setter property be compiled as CompiledProp::Accessor")
}
Prop::Method(p) => AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: MemberExpr {
span: DUMMY_SP,
obj: temp.clone().into(),
prop: p.key.into(),
}
.into(),
right: p.function.into(),
}
.into(),
},
CompiledProp::Accessor(getter, setter) => {
let key = getter
.as_ref()
.map(|v| v.key.clone())
.unwrap_or_else(|| setter.as_ref().unwrap().key.clone());
let desc = ObjectLit {
span: DUMMY_SP,
props: getter
.map(|g| KeyValueProp {
key: quote_ident!("get").into(),
value: Function {
params: Vec::new(),
span: g.span,
body: g.body,
is_generator: false,
is_async: false,
..Default::default()
}
.into(),
})
.into_iter()
.chain(setter.map(|s| {
KeyValueProp {
key: quote_ident!("set").into(),
value: Function {
params: vec![(*s.param).into()],
span: s.span,
body: s.body,
is_generator: false,
is_async: false,
..Default::default()
}
.into(),
}
}))
.map(Prop::KeyValue)
.map(Box::new)
.map(PropOrSpread::Prop)
.collect(),
};
CallExpr {
span: DUMMY_SP,
callee: helper!(define_property),
args: vec![
temp.clone().as_arg(),
prop_name_to_expr_value(key).as_arg(),
desc.as_arg(),
],
..Default::default()
}
.into()
}
};
expression.visit_mut_with(self);
if !expression.is_invalid() {
expressions.push(Box::new(expression));
}
expressions
}
fn visit_left_associative_bin_expr(&mut self, node: &mut BinExpr) -> Option<Expr> {
if contains_yield(&node.right) {
if matches!(node.op, op!("||") | op!("&&")) {
return Some(self.visit_logical_bin_expr(node));
}
// [source]
// a() + (yield) + c()
//
// [intermediate]
// .local _a
// _a = a();
// .yield resumeLabel
// _a + %sent% + c()
node.left.visit_mut_with(self);
node.left = self.cache_expression(node.left.take()).into();
node.right.visit_mut_with(self);
return None;
}
node.visit_mut_children_with(self);
None
}
fn visit_logical_bin_expr(&mut self, node: &mut BinExpr) -> Expr {
// Logical binary expressions (`&&` and `||`) are shortcutting
// expressions and need to be transformed as such:
//
// [source]
// x = a() && yield;
//
// [intermediate]
// .local _a
// _a = a();
// .brfalse resultLabel, (_a)
// .yield resumeLabel
// .mark resumeLabel
// _a = %sent%;
// .mark resultLabel
// x = _a;
//
// [source]
// x = a() || yield;
//
// [intermediate]
// .local _a
// _a = a();
// .brtrue resultLabel, (_a)
// .yield resumeLabel
// .mark resumeLabel
// _a = %sent%;
// .mark resultLabel
// x = _a;
let result_label = self.define_label();
let result_local = self.declare_local(None);
let left_span = node.left.span();
node.left.visit_mut_with(self);
self.emit_assignment(
result_local.clone().into(),
node.left.take(),
Some(left_span),
);
if node.op == op!("&&") {
// Logical `&&` shortcuts when the left-hand operand is falsey.
self.emit_break_when_false(
result_label,
Box::new(result_local.clone().into()),
Some(left_span),
)
} else {
// Logical `||` shortcuts when the left-hand operand is truthy.
self.emit_break_when_true(
result_label,
Box::new(result_local.clone().into()),
Some(left_span),
)
}
let right_span = node.right.span();
node.right.visit_mut_with(self);
self.emit_assignment(
result_local.clone().into(),
node.right.take(),
Some(right_span),
);
self.mark_label(result_label);
result_local.into()
}
fn transform_and_emit_stmts(&mut self, stmts: Vec<Stmt>, start: usize) {
for s in stmts.into_iter().skip(start) {
self.transform_and_emit_stmt(s);
}
}
fn transform_and_emit_embedded_stmt(&mut self, node: Stmt) {
if let Stmt::Block(block) = node {
self.transform_and_emit_stmts(block.stmts, 0);
} else {
self.transform_and_emit_stmt(node);
}
}
fn transform_and_emit_stmt(&mut self, node: Stmt) {
let _tracing = dev_span!("transform_and_emit_stmt");
let saved_in_statement_containing_yield = self.in_statement_containing_yield;
if !self.in_statement_containing_yield {
self.in_statement_containing_yield = contains_yield(&node);
}
self.transform_and_emit_stmt_worker(node);
self.in_statement_containing_yield = saved_in_statement_containing_yield;
}
fn transform_and_emit_stmt_worker(&mut self, mut node: Stmt) {
match node {
Stmt::Block(s) => self.transform_and_emit_block(s),
Stmt::Expr(s) => self.transform_and_emit_expr_stmt(s),
Stmt::If(s) => self.transform_and_emit_if_stmt(s),
Stmt::DoWhile(s) => self.transform_and_emit_do_stmt(s),
Stmt::While(s) => self.transform_and_emit_while_stmt(s),
Stmt::For(s) => self.transform_and_emit_for_stmt(s),
Stmt::ForIn(s) => self.transform_and_emit_for_in_stmt(s),
Stmt::Continue(s) => self.transform_and_emit_continue_stmt(s),
Stmt::Break(s) => self.transform_and_emit_break_stmt(s),
Stmt::Return(s) => self.transform_and_emit_return_stmt(s),
Stmt::With(s) => self.transform_and_emit_with_stmt(s),
Stmt::Switch(s) => self.transform_and_emit_switch_stmt(s),
Stmt::Labeled(s) => self.transform_and_emit_labeled_stmt(s),
Stmt::Throw(s) => self.transform_and_emit_throw_stmt(s),
Stmt::Try(s) => self.transform_and_emit_try_stmt(*s),
_ => {
node.visit_mut_with(self);
self.emit_stmt(node);
}
}
}
fn transform_and_emit_block(&mut self, mut node: BlockStmt) {
if contains_yield(&node) {
self.transform_and_emit_stmts(node.stmts, 0);
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn transform_and_emit_expr_stmt(&mut self, mut node: ExprStmt) {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
fn transform_and_emit_var_decl_list(&mut self, mut node: Box<VarDecl>) {
for variable in &node.decls {
self.hoist_variable_declaration(&Ident::from(variable.name.as_ident().unwrap()));
}
let mut variables = self.get_initialized_variables(&mut node);
let var_len = variables.len();
let mut variables_written = 0;
let mut pending_expressions = Vec::new();
let mut cnt = 0;
while variables_written < var_len {
#[cfg(debug_assertions)]
debug!("variables_written: {} / {}", variables_written, var_len);
for (_i, variable) in variables.iter_mut().enumerate().skip(variables_written) {
if contains_yield(&**variable) && cnt != 0 {
break;
}
// We use cnt because variable.init can be None.
let expr = self.transform_initialized_variable(variable.take());
pending_expressions.extend(expr.map(Expr::from).map(Box::new));
cnt += 1;
}
if cnt > 0 {
variables_written += cnt;
cnt = 0;
self.emit_stmt(
ExprStmt {
span: DUMMY_SP,
expr: if pending_expressions.len() == 1 {
pending_expressions.pop().unwrap()
} else {
SeqExpr {
span: DUMMY_SP,
exprs: take(&mut pending_expressions),
}
.into()
},
}
.into(),
)
}
}
}
fn transform_initialized_variable(&mut self, mut node: VarDeclarator) -> Option<AssignExpr> {
node.init.visit_mut_with(self);
node.init.map(|right| AssignExpr {
span: node.span,
op: op!("="),
left: node.name.clone().try_into().unwrap(),
right,
})
}
fn transform_and_emit_if_stmt(&mut self, mut node: IfStmt) {
if contains_yield(&node) {
// [source]
// if (x)
// /*thenStatement*/
// else
// /*elseStatement*/
//
// [intermediate]
// .brfalse elseLabel, (x)
// /*thenStatement*/
// .br endLabel
// .mark elseLabel
// /*elseStatement*/
// .mark endLabel
if contains_yield(&node.cons) || contains_yield(&node.alt) {
let end_label = self.define_label();
let else_label = node.alt.as_ref().map(|_| self.define_label());
node.test.visit_mut_with(self);
let span = node.test.span();
self.emit_break_when_false(else_label.unwrap_or(end_label), node.test, Some(span));
self.transform_and_emit_embedded_stmt(*node.cons);
if let Some(alt) = node.alt {
self.emit_break(end_label, None);
self.mark_label(else_label.unwrap());
self.transform_and_emit_embedded_stmt(*alt);
}
self.mark_label(end_label);
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn transform_and_emit_do_stmt(&mut self, mut node: DoWhileStmt) {
if contains_yield(&node) {
// [source]
// do {
// /*body*/
// }
// while (i < 10);
//
// [intermediate]
// .loop conditionLabel, endLabel
// .mark loopLabel
// /*body*/
// .mark conditionLabel
// .brtrue loopLabel, (i < 10)
// .endloop
// .mark endLabel
let condition_label = self.define_label();
let loop_label = self.define_label();
self.begin_loop_block(condition_label);
self.mark_label(loop_label);
self.transform_and_emit_embedded_stmt(*node.body);
self.mark_label(condition_label);
node.test.visit_mut_with(self);
let span = node.test.span();
self.emit_break_when_true(loop_label, node.test, Some(span));
self.end_loop_block();
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn transform_and_emit_while_stmt(&mut self, mut node: WhileStmt) {
let _tracing = dev_span!("transform_and_emit_while_stmt");
if contains_yield(&node) {
// [source]
// while (i < 10) {
// /*body*/
// }
//
// [intermediate]
// .loop loopLabel, endLabel
// .mark loopLabel
// .brfalse endLabel, (i < 10)
// /*body*/
// .br loopLabel
// .endloop
// .mark endLabel
let loop_label = self.define_label();
let end_label = self.begin_loop_block(loop_label);
self.mark_label(loop_label);
node.test.visit_mut_with(self);
self.emit_break_when_false(end_label, node.test, None);
self.transform_and_emit_embedded_stmt(*node.body);
self.emit_break(loop_label, None);
self.end_loop_block();
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn transform_and_emit_for_stmt(&mut self, mut node: ForStmt) {
if contains_yield(&node) {
// [source]
// for (var i = 0; i < 10; i++) {
// /*body*/
// }
//
// [intermediate]
// .local i
// i = 0;
// .loop incrementLabel, endLoopLabel
// .mark conditionLabel
// .brfalse endLoopLabel, (i < 10)
// /*body*/
// .mark incrementLabel
// i++;
// .br conditionLabel
// .endloop
// .mark endLoopLabel
let condition_label = self.define_label();
let increment_label = self.define_label();
let end_label = self.begin_loop_block(increment_label);
if let Some(init) = node.init {
match init {
VarDeclOrExpr::VarDecl(init) => {
self.transform_and_emit_var_decl_list(init);
}
VarDeclOrExpr::Expr(mut init) => {
init.visit_mut_with(self);
self.emit_stmt(
ExprStmt {
span: init.span(),
expr: init,
}
.into(),
);
}
}
}
self.mark_label(condition_label);
if let Some(mut cond) = node.test {
cond.visit_mut_with(self);
self.emit_break_when_false(end_label, cond, None);
}
self.transform_and_emit_embedded_stmt(*node.body);
self.mark_label(increment_label);
if let Some(mut incrementor) = node.update {
incrementor.visit_mut_with(self);
self.emit_stmt(
ExprStmt {
span: incrementor.span(),
expr: incrementor,
}
.into(),
);
}
self.emit_break(condition_label, None);
self.end_loop_block();
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn transform_and_emit_for_in_stmt(&mut self, mut node: ForInStmt) {
if contains_yield(&node) {
// [source]
// for (var p in o) {
// /*body*/
// }
//
// [intermediate]
// .local _a, _b, _i
// _a = [];
// for (_b in o) _a.push(_b);
// _i = 0;
// .loop incrementLabel, endLoopLabel
// .mark conditionLabel
// .brfalse endLoopLabel, (_i < _a.length)
// p = _a[_i];
// /*body*/
// .mark incrementLabel
// _b++;
// .br conditionLabel
// .endloop
// .mark endLoopLabel
let keys_array = self.declare_local(None);
let key = self.declare_local(None);
let keys_index = private_ident!("_i");
self.hoist_variable_declaration(&keys_index);
self.emit_assignment(
keys_array.clone().into(),
Box::new(ArrayLit::dummy().into()),
None,
);
node.right.visit_mut_with(self);
self.emit_stmt(
ForInStmt {
span: DUMMY_SP,
left: ForHead::Pat(key.clone().into()),
right: node.right.take(),
body: Box::new(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: CallExpr {
span: DUMMY_SP,
callee: keys_array
.clone()
.make_member(quote_ident!("push"))
.as_callee(),
args: vec![key.as_arg()],
..Default::default()
}
.into(),
})),
}
.into(),
);
self.emit_assignment(keys_index.clone().into(), 0.into(), None);
let condition_label = self.define_label();
let increment_label = self.define_label();
let end_label = self.begin_loop_block(increment_label);
self.mark_label(condition_label);
self.emit_break_when_false(
end_label,
Box::new(keys_index.clone().make_bin(
op!("<"),
keys_array.clone().make_member(quote_ident!("length")),
)),
None,
);
let variable = match node.left {
ForHead::VarDecl(initializer) => {
for variable in initializer.decls.iter() {
self.hoist_variable_declaration(&Ident::from(
variable.name.as_ident().unwrap(),
));
}
initializer.decls[0].name.clone()
}
ForHead::Pat(mut initializer) => {
initializer.visit_mut_with(self);
*initializer
}
ForHead::UsingDecl(..) => {
unreachable!("using declaration must be removed by previous pass")
}
};
self.emit_assignment(
variable.try_into().unwrap(),
MemberExpr {
span: DUMMY_SP,
obj: Box::new(keys_array.into()),
prop: MemberProp::Computed(ComputedPropName {
span: DUMMY_SP,
expr: Box::new(keys_index.clone().into()),
}),
}
.into(),
None,
);
self.transform_and_emit_embedded_stmt(*node.body);
self.mark_label(increment_label);
self.emit_stmt(
ExprStmt {
span: DUMMY_SP,
expr: UpdateExpr {
span: DUMMY_SP,
prefix: false,
op: op!("++"),
arg: Box::new(keys_index.clone().into()),
}
.into(),
}
.into(),
);
self.emit_break(condition_label, None);
self.end_loop_block();
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn transform_and_emit_continue_stmt(&mut self, node: ContinueStmt) {
let label = self.find_continue_target(node.label.as_ref().map(|l| l.sym.clone()));
if label.0 > 0 {
self.emit_break(label, Some(node.span));
} else {
// invalid continue without a containing loop. Leave the node as is,
// per #17875.
self.emit_stmt(node.into())
}
}
fn transform_and_emit_break_stmt(&mut self, node: BreakStmt) {
let label = self.find_break_target(node.label.as_ref().map(|l| l.sym.clone()));
if label.0 > 0 {
self.emit_break(label, Some(node.span));
} else {
// invalid break without a containing loop. Leave the node as is,
// per #17875.
self.emit_stmt(node.into())
}
}
fn transform_and_emit_return_stmt(&mut self, mut s: ReturnStmt) {
s.arg.visit_mut_with(self);
self.emit_return(s.arg, Some(s.span))
}
fn transform_and_emit_with_stmt(&mut self, mut node: WithStmt) {
if contains_yield(&node) {
// [source]
// with (x) {
// /*body*/
// }
//
// [intermediate]
// .with (x)
// /*body*/
// .endwith
node.obj.visit_mut_with(self);
let obj = self.cache_expression(node.obj);
self.begin_with_block(obj);
self.transform_and_emit_embedded_stmt(*node.body);
self.end_with_block();
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn transform_and_emit_switch_stmt(&mut self, mut node: SwitchStmt) {
if contains_yield(&node.cases) {
// [source]
// switch (x) {
// case a:
// /*caseStatements*/
// case b:
// /*caseStatements*/
// default:
// /*defaultStatements*/
// }
//
// [intermediate]
// .local _a
// .switch endLabel
// _a = x;
// switch (_a) {
// case a:
// .br clauseLabels[0]
// }
// switch (_a) {
// case b:
// .br clauseLabels[1]
// }
// .br clauseLabels[2]
// .mark clauseLabels[0]
// /*caseStatements*/
// .mark clauseLabels[1]
// /*caseStatements*/
// .mark clauseLabels[2]
// /*caseStatements*/
// .endswitch
// .mark endLabel
let end_label = self.begin_switch_block();
node.discriminant.visit_mut_with(self);
let expression = self.cache_expression(node.discriminant);
// Create labels for each clause and find the index of the first
// default clause.
let mut clause_labels = Vec::new();
let mut default_clause_index = -1i32;
for (i, clause) in node.cases.iter().enumerate() {
clause_labels.push(self.define_label());
if clause.test.is_none() && default_clause_index == -1 {
default_clause_index = i as _;
}
}
// Emit switch statements for each run of case clauses either from
// the first case clause or the next case clause with a
// `yield` in its expression, up to the next case clause
// with a `yield` in its expression.
let mut clauses_written = 0;
let mut pending_clauses = Vec::new();
while clauses_written < node.cases.len() {
#[cfg(debug_assertions)]
debug!("clauses_written: {}", clauses_written);
let mut default_clauses_skipped = 0;
for (i, clause) in node.cases.iter_mut().enumerate().skip(clauses_written) {
if clause.test.is_some() {
if contains_yield(&clause.test) && !pending_clauses.is_empty() {
break;
}
clause.test.visit_mut_with(self);
let span = clause.test.span();
pending_clauses.push(SwitchCase {
span: DUMMY_SP,
test: clause.test.take(),
cons: vec![self
.create_inline_break(clause_labels[i], Some(span))
.into()],
})
} else {
default_clauses_skipped += 1;
}
}
if !pending_clauses.is_empty() {
clauses_written += pending_clauses.len();
self.emit_stmt(
SwitchStmt {
span: DUMMY_SP,
discriminant: expression.clone().into(),
cases: take(&mut pending_clauses),
}
.into(),
);
}
if default_clauses_skipped > 0 {
clauses_written += default_clauses_skipped;
}
}
if default_clause_index >= 0 {
self.emit_break(clause_labels[default_clause_index as usize], None);
} else {
self.emit_break(end_label, None);
}
for (i, clause) in node.cases.into_iter().enumerate() {
self.mark_label(clause_labels[i]);
self.transform_and_emit_stmts(clause.cons, 0);
}
self.end_switch_block()
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into())
}
}
fn transform_and_emit_labeled_stmt(&mut self, mut node: LabeledStmt) {
#[cfg(debug_assertions)]
debug!("transform_and_emit_labeled_stmt: {:?}", node.label);
if contains_yield(&node) {
// [source]
// x: {
// /*body*/
// }
//
// [intermediate]
// .labeled "x", endLabel
// /*body*/
// .endlabeled
// .mark endLabel
self.begin_labeled_block(node.label.sym);
self.transform_and_emit_embedded_stmt(*node.body);
self.end_labeled_block();
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn transform_and_emit_throw_stmt(&mut self, mut node: ThrowStmt) {
node.arg.visit_mut_with(self);
self.emit_throw(node.arg, Some(node.span))
}
fn transform_and_emit_try_stmt(&mut self, mut node: TryStmt) {
let _tracing = dev_span!("transform_and_emit_try_stmt");
if contains_yield(&node) {
// [source]
// try {
// /*tryBlock*/
// }
// catch (e) {
// /*catchBlock*/
// }
// finally {
// /*finallyBlock*/
// }
//
// [intermediate]
// .local _a
// .try tryLabel, catchLabel, finallyLabel, endLabel
// .mark tryLabel
// .nop
// /*tryBlock*/
// .br endLabel
// .catch
// .mark catchLabel
// _a = %error%;
// /*catchBlock*/
// .br endLabel
// .finally
// .mark finallyLabel
// /*finallyBlock*/
// .endfinally
// .endtry
// .mark endLabel
self.begin_exception_block();
self.transform_and_emit_embedded_stmt(node.block.into());
if let Some(catch) = node.handler {
self.begin_catch_block(VarDeclarator {
name: catch.param.clone().unwrap(),
..Take::dummy()
});
self.transform_and_emit_embedded_stmt(catch.body.into());
}
if let Some(finalizer) = node.finalizer {
self.begin_finally_block();
self.transform_and_emit_embedded_stmt(finalizer.into());
}
self.end_exception_block();
} else {
node.visit_mut_with(self);
self.emit_stmt(node.into());
}
}
fn count_initial_nodes_without_yield<N>(&self, nodes: &[N]) -> usize
where
N: VisitWith<YieldFinder>,
{
for (i, node) in nodes.iter().enumerate() {
if contains_yield(node) {
return i;
}
}
0
}
fn cache_expression(&mut self, node: Box<Expr>) -> Ident {
match *node {
Expr::Ident(i) => i,
_ => {
let span = node.span();
let temp = self.create_temp_variable();
self.emit_assignment(temp.clone().into(), node, Some(span));
temp
}
}
}
fn declare_local(&mut self, name: Option<Atom>) -> Ident {
let temp = name
.map(|name| private_ident!(name))
.unwrap_or_else(|| private_ident!("_tmp"));
self.hoist_variable_declaration(&temp);
temp
}
/// Defines a label, uses as the target of a Break operation.
fn define_label(&mut self) -> Label {
if self.label_offsets.is_none() {
self.label_offsets = Some(Default::default());
}
let label = Label(self.next_label_id as _);
self.next_label_id += 1;
#[cfg(debug_assertions)]
debug!("define_label: {:?}", label);
if label.0 as usize >= self.label_offsets.as_ref().unwrap().len() {
self.label_offsets
.as_mut()
.unwrap()
.resize(label.0 as usize + 1, 0);
}
self.label_offsets.as_mut().unwrap()[label.0 as usize] = -1;
label
}
/// Marks the current operation with the specified label.
fn mark_label(&mut self, label: Label) {
debug_assert!(self.label_offsets.is_some(), "No labels were defined.");
if label.0 as usize >= self.label_offsets.as_ref().unwrap().len() {
self.label_offsets
.as_mut()
.unwrap()
.resize(label.0 as usize + 1, Default::default());
}
self.label_offsets.as_mut().unwrap()[label.0 as usize] =
self.operations.as_deref().map_or(0, |v| v.len() as _);
#[cfg(debug_assertions)]
debug!(
"mark_label: {:?}; offset: {}",
label,
self.label_offsets.as_mut().unwrap()[label.0 as usize]
);
}
//// Begins a block operation (With, Break/Continue, Try/Catch/Finally)
///
/// - `block`: Information about the block.
fn begin_block(&mut self, block: CodeBlock) -> Ptr<CodeBlock> {
if self.blocks.is_none() {
self.blocks = Some(Default::default());
self.block_actions = Some(Default::default());
self.block_offsets = Some(Default::default());
self.block_stack = Some(Default::default());
}
let index = self.block_actions.as_ref().unwrap().len();
#[cfg(debug_assertions)]
if cfg!(debug_assertions) {
debug!("Begin block {}: {:?}", index, block);
}
let block = Rc::new(RefCell::new(block));
self.block_actions.as_mut().unwrap().push(BlockAction::Open);
self.block_offsets
.as_mut()
.unwrap()
.push(self.operations.as_ref().map_or(0, |v| v.len()));
self.blocks.as_mut().unwrap().push(block.clone());
self.block_stack.as_mut().unwrap().push(block.clone());
block
}
/// Ends the current block operation.
fn end_block(&mut self) -> Ptr<CodeBlock> {
let block = self.peek_block().expect("beginBlock was never called.");
let index = self.block_actions.as_ref().unwrap().len();
#[cfg(debug_assertions)]
debug!("End block {}", index);
self.block_actions
.as_mut()
.unwrap()
.push(BlockAction::Close);
self.block_offsets
.as_mut()
.unwrap()
.push(self.operations.as_ref().map_or(0, |v| v.len()));
self.blocks.as_mut().unwrap().push(block.clone());
self.block_stack.as_mut().unwrap().pop();
block
}
/// Gets the current open block.
fn peek_block(&self) -> Option<Ptr<CodeBlock>> {
self.block_stack.as_ref().and_then(|v| v.last().cloned())
}
/// Gets the kind of the current open block.
fn peek_block_kind(&self) -> Option<CodeBlockKind> {
self.peek_block().map(|b| match &*b.borrow() {
CodeBlock::With(..) => CodeBlockKind::With,
CodeBlock::Exception(..) => CodeBlockKind::Exception,
CodeBlock::Labeled(..) => CodeBlockKind::Labeled,
CodeBlock::Switch(..) => CodeBlockKind::Switch,
CodeBlock::Loop(..) => CodeBlockKind::Loop,
})
}
/// Begins a code block for a generated `with` statement.
///
/// - `expression`: An identifier representing expression for the `with`
fn begin_with_block(&mut self, expr: Ident) {
let start_label = self.define_label();
let end_label = self.define_label();
self.mark_label(start_label);
self.begin_block(CodeBlock::With(WithBlock {
expression: expr,
start_label,
end_label,
}));
}
/// Ends a code block for a generated `with` statement.
fn end_with_block(&mut self) {
debug_assert!(self.peek_block_kind() == Some(CodeBlockKind::With));
let block = self.end_block();
let b = block.borrow();
if let CodeBlock::With(block) = &*b {
self.mark_label(block.end_label);
} else {
unreachable!()
}
}
/// Begins a code block for a generated `try` statement.
fn begin_exception_block(&mut self) -> Label {
let _tracing = dev_span!("begin_exception_block");
let start_label = self.define_label();
let end_label = self.define_label();
self.mark_label(start_label);
self.begin_block(CodeBlock::Exception(ExceptionBlock {
state: ExceptionBlockState::Try,
start_label,
end_label,
catch_variable: Default::default(),
catch_label: Default::default(),
finally_label: Default::default(),
}));
self.emit_nop();
end_label
}
/**
* Enters the `catch` clause of a generated `try` statement.
*
* @param variable The catch variable.
*/
fn begin_catch_block(&mut self, variable: VarDeclarator) {
debug_assert!(self.peek_block_kind() == Some(CodeBlockKind::Exception));
let name = variable.name.expect_ident().into();
self.hoist_variable_declaration(&name);
// ExceptionBlock
let peeked = self.peek_block().unwrap();
let exception = peeked.borrow_mut();
let mut exception = RefMut::map(exception, |v| match v {
CodeBlock::Exception(v) => v,
_ => unreachable!(),
});
debug_assert!(exception.state < ExceptionBlockState::Catch);
let end_label = exception.end_label;
self.emit_break(end_label, None);
let catch_label = self.define_label();
self.mark_label(catch_label);
exception.state = ExceptionBlockState::Catch;
exception.catch_variable = Some(name.clone());
exception.catch_label = Some(catch_label);
self.emit_assignment(
name.clone().into(),
CallExpr {
span: DUMMY_SP,
callee: self
.state
.clone()
.make_member(quote_ident!("sent"))
.as_callee(),
args: Vec::new(),
..Default::default()
}
.into(),
None,
);
self.emit_nop();
}
/// Enters the `finally` block of a generated `try` statement.
fn begin_finally_block(&mut self) {
let _tracing = dev_span!("begin_finally_block");
debug_assert!(self.peek_block_kind() == Some(CodeBlockKind::Exception));
let block = self.peek_block().unwrap();
let mut b = block.borrow_mut();
if let CodeBlock::Exception(block) = &mut *b {
debug_assert!(block.state < ExceptionBlockState::Finally);
let end_label = block.end_label;
self.emit_break(end_label, None);
let finally_label = self.define_label();
self.mark_label(finally_label);
block.state = ExceptionBlockState::Finally;
block.finally_label = Some(finally_label);
} else {
unreachable!()
}
}
/// Ends the code block for a generated `try` statement.
fn end_exception_block(&mut self) {
debug_assert!(self.peek_block_kind() == Some(CodeBlockKind::Exception));
let block = self.end_block();
let mut b = block.borrow_mut();
if let CodeBlock::Exception(block) = &mut *b {
let state = block.state;
if state < ExceptionBlockState::Finally {
self.emit_break(block.end_label, None);
} else {
self.emit_endfinally();
}
self.mark_label(block.end_label);
self.emit_nop();
block.state = ExceptionBlockState::Done;
} else {
unreachable!()
}
}
/// Begins a code block that supports `break` or `continue` statements that
/// are defined in the source tree and not from generated code.
fn begin_script_loop_block(&mut self) {
self.begin_block(CodeBlock::Loop(LoopBlock {
is_script: true,
break_label: Label(-1),
continue_label: Label(-1),
}));
}
/// Begins a code block that supports `break` or `continue` statements that
/// are defined in generated code. Returns a label used to mark the
/// operation to which to jump when a `break` statement targets this block.
///
/// - `continue_label`: A Label used to mark the operation to which to jump
/// when a `continue` statement targets this block.
fn begin_loop_block(&mut self, continue_label: Label) -> Label {
let _tracing = dev_span!("begin_loop_block");
let break_label = self.define_label();
self.begin_block(CodeBlock::Loop(LoopBlock {
is_script: false,
break_label,
continue_label,
}));
break_label
}
/// Ends a code block that supports `break` or `continue` statements that
/// are defined in generated code or in the source tree.
fn end_loop_block(&mut self) {
debug_assert!(self.peek_block_kind() == Some(CodeBlockKind::Loop));
let block = self.end_block();
let block = block.borrow();
if let CodeBlock::Loop(block) = &*block {
let break_label = block.break_label;
if !block.is_script {
self.mark_label(break_label);
}
} else {
unreachable!()
}
}
/// Begins a code block that supports `break` statements that are defined in
/// the source tree and not from generated code.
fn begin_script_switch_block(&mut self) {
self.begin_block(CodeBlock::Switch(SwitchBlock {
is_script: true,
break_label: Label(-1),
}));
}
/// Begins a code block that supports `break` statements that are defined in
/// generated code.
///
/// Returns a label used to mark the operation to which to jump when a
/// `break` statement targets this block.
fn begin_switch_block(&mut self) -> Label {
let break_label = self.define_label();
self.begin_block(CodeBlock::Switch(SwitchBlock {
is_script: false,
break_label,
}));
break_label
}
/// Ends a code block that supports `break` statements that are defined in
/// generated code.
fn end_switch_block(&mut self) {
debug_assert!(self.peek_block_kind() == Some(CodeBlockKind::Switch));
let block = self.end_block();
let block = block.borrow();
if let CodeBlock::Switch(block) = &*block {
let break_label = block.break_label;
if !block.is_script {
self.mark_label(break_label);
}
} else {
unreachable!()
}
}
fn begin_script_labeled_block(&mut self, label_text: Atom) {
self.begin_block(CodeBlock::Labeled(LabeledBlock {
is_script: true,
label_text,
break_label: Label(-1),
}));
}
fn begin_labeled_block(&mut self, label_text: Atom) {
let break_label = self.define_label();
self.begin_block(CodeBlock::Labeled(LabeledBlock {
is_script: false,
label_text,
break_label,
}));
}
fn end_labeled_block(&mut self) {
let block = self.end_block();
if !block.borrow().is_script() {
let break_label = match &*block.borrow() {
CodeBlock::Labeled(block) => block.break_label,
_ => unreachable!(),
};
self.mark_label(break_label);
}
}
/// Indicates whether the provided block supports `break` statements.
fn supports_unlabeled_break(&self, block: &CodeBlock) -> bool {
matches!(block, CodeBlock::Switch(..) | CodeBlock::Loop(..))
}
/// Indicates whether the provided block supports `break` statements with
/// labels.
fn supports_labeled_break_or_continue(&self, block: &CodeBlock) -> bool {
matches!(block, CodeBlock::Labeled(..))
}
/// Indicates whether the provided block supports `continue` statements.
fn supports_unlabeled_continue(&self, block: &CodeBlock) -> bool {
matches!(block, CodeBlock::Loop(..))
}
fn has_immediate_containing_labeled_block(&self, label_text: &Atom, start: usize) -> bool {
for i in (0..=start).rev() {
let block = self.block_stack.as_ref().unwrap()[i].clone();
if self.supports_labeled_break_or_continue(&block.borrow()) {
if let CodeBlock::Labeled(block) = &*block.borrow() {
if block.label_text == *label_text {
return true;
}
} else {
unreachable!()
}
} else {
break;
}
}
false
}
/// Finds the label that is the target for a `break` statement.
///
/// - `label_text`: An optional name of a containing labeled statement.
fn find_break_target(&self, label_text: Option<Atom>) -> Label {
#[cfg(debug_assertions)]
debug!("find_break_target: label_text={:?}", label_text);
if let Some(block_stack) = &self.block_stack {
if let Some(label_text) = label_text {
for i in (0..=block_stack.len() - 1).rev() {
let block = &block_stack[i];
if (self.supports_labeled_break_or_continue(&block.borrow())
&& block.borrow().label_text().unwrap() == label_text)
|| (self.supports_unlabeled_break(&block.borrow())
&& self.has_immediate_containing_labeled_block(&label_text, i - 1))
{
return block.borrow().break_label().unwrap();
}
}
} else {
for i in (0..=block_stack.len() - 1).rev() {
let block = &block_stack[i];
if self.supports_unlabeled_break(&block.borrow()) {
return block.borrow().break_label().unwrap();
}
}
}
}
Label(0)
}
/// Finds the label that is the target for a `continue` statement.
///
/// - `labelText` An optional name of a containing labeled statement.
fn find_continue_target(&self, label_text: Option<Atom>) -> Label {
if let Some(block_stack) = &self.block_stack {
if let Some(label_text) = label_text {
for i in (0..=block_stack.len() - 1).rev() {
let block = &block_stack[i];
if self.supports_unlabeled_continue(&block.borrow())
&& self.has_immediate_containing_labeled_block(&label_text, i - 1)
{
return block.borrow().continue_label().unwrap();
}
}
} else {
for i in (0..=block_stack.len() - 1).rev() {
let block = &block_stack[i];
if self.supports_unlabeled_continue(&block.borrow()) {
return block.borrow().continue_label().unwrap();
}
}
}
}
Label(0)
}
/// Creates an expression that can be used to indicate the value for a
/// label.
fn create_label(&mut self, label: Option<Label>) -> Box<Expr> {
if let Some(label) = label {
if label.0 > 0 {
#[cfg(debug_assertions)]
debug!("create_label: label={:?}", label);
if self.label_exprs.is_none() {
self.label_exprs = Some(Default::default());
}
let label_expressions = self.label_exprs.as_mut().unwrap();
let expr = Loc {
pos: BytePos(label.0 as _),
value: -1,
};
if label_expressions.get(label.0 as usize).is_none() {
if label.0 as usize >= label_expressions.len() {
label_expressions.resize(label.0 as usize + 1, Vec::new());
}
label_expressions[label.0 as usize] = vec![expr];
} else {
label_expressions
.get_mut(label.0 as usize)
.unwrap()
.push(expr);
}
return Invalid {
span: Span::new(BytePos(label.0 as _), BytePos(label.0 as _)),
}
.into();
}
}
Box::new(Invalid { span: DUMMY_SP }.into())
}
/// Creates a numeric literal for the provided instruction.
fn create_instruction(&mut self, instruction: Instruction) -> Number {
// TODO(kdy1):
// self.add_synthetic_trailing_comment(
// literal,
// SyntaxKind::MultiLineCommentTrivia,
// get_instruction_name(instruction),
// );
Number {
span: DUMMY_SP,
value: instruction as u16 as _,
raw: None,
}
}
/// Creates a statement that can be used indicate a Break operation to the
/// provided label.
///
/// - `label`: A label.
/// - `location`: An optional source map location for the statement.
fn create_inline_break(&mut self, label: Label, span: Option<Span>) -> ReturnStmt {
debug_assert!(label.0 >= 0, "Invalid label");
let args = vec![
Some(self.create_instruction(Instruction::Break).as_arg()),
Some(self.create_label(Some(label)).as_arg()),
];
ReturnStmt {
span: span.unwrap_or(DUMMY_SP),
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems: args,
}
.into(),
),
}
}
/// Creates a statement that can be used indicate a Return operation.
///
/// - `expr`: The expression for the return statement.
/// - `loc`: An optional source map location for the statement.
fn create_inline_return(&mut self, expr: Option<Box<Expr>>, loc: Option<Span>) -> ReturnStmt {
ReturnStmt {
span: loc.unwrap_or(DUMMY_SP),
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems: match expr {
Some(expr) => vec![
Some(self.create_instruction(Instruction::Return).as_arg()),
Some(expr.as_arg()),
],
None => vec![Some(self.create_instruction(Instruction::Return).as_arg())],
},
}
.into(),
),
}
}
/// Creates an expression that can be used to resume from a Yield operation.
fn create_generator_resume(&mut self, loc: Option<Span>) -> Box<Expr> {
CallExpr {
span: loc.unwrap_or(DUMMY_SP),
callee: self
.state
.clone()
.make_member(quote_ident!("sent"))
.as_callee(),
args: Vec::new(),
..Default::default()
}
.into()
}
/// Emits an empty instruction.
fn emit_nop(&mut self) {
self.emit_worker(OpCode::Nop, None, None);
}
/// Emits a Statement.
///
/// - `stmt`: A statement.
fn emit_stmt(&mut self, stmt: Stmt) {
if stmt.is_empty() {
self.emit_nop();
} else {
self.emit_worker(OpCode::Statement, Some(OpArgs::Stmt(Box::new(stmt))), None);
}
}
/// Emits an Assignment operation.
///
/// - `left`: The left-hand side of the assignment.
/// - `right`: The right-hand side of the assignment.
/// - `loc`: An optional source map location for the assignment.
fn emit_assignment(&mut self, left: AssignTarget, right: Box<Expr>, loc: Option<Span>) {
self.emit_worker(OpCode::Assign, Some(OpArgs::PatAndExpr(left, right)), loc);
}
/// Emits a Break operation to the specified label.
///
/// - `label`: A label.
/// - `loc`: An optional source map location for the assignment.
fn emit_break(&mut self, label: Label, loc: Option<Span>) {
self.emit_worker(OpCode::Break, Some(OpArgs::Label(label)), loc);
}
/// Emits a Break operation to the specified label when a condition
/// evaluates to a truthy value at runtime.
///
/// - `label`: A label.
/// - `condition`: The condition.
/// - `loc`: An optional source map location for the assignment.
fn emit_break_when_true(&mut self, label: Label, condition: Box<Expr>, loc: Option<Span>) {
self.emit_worker(
OpCode::BreakWhenTrue,
Some(OpArgs::LabelExpr(label, condition)),
loc,
);
}
/// Emits a Break to the specified label when a condition evaluates to a
/// falsy value at runtime
///
/// - `label`: A label.
/// - `condition`: The condition.
/// - `loc`: An optional source map location for the assignment.
fn emit_break_when_false(&mut self, label: Label, condition: Box<Expr>, loc: Option<Span>) {
self.emit_worker(
OpCode::BreakWhenFalse,
Some(OpArgs::LabelExpr(label, condition)),
loc,
);
}
/// Emits a YieldStar operation for the provided expression.
///
/// - `expr`: An optional value for the yield operation.
/// - `loc`: An optional source map location for the assignment.
fn emit_yield_star(&mut self, expr: Option<Box<Expr>>, loc: Option<Span>) {
self.emit_worker(OpCode::YieldStar, Some(OpArgs::OptExpr(expr)), loc);
}
/// Emits a Yield operation for the provided expression.
///
/// - `expr`: An optional value for the yield operation.
/// - `loc`: An optional source map location for the assignment.
fn emit_yield(&mut self, expr: Option<Box<Expr>>, loc: Option<Span>) {
self.emit_worker(OpCode::Yield, Some(OpArgs::OptExpr(expr)), loc);
}
/// Emits a Return operation for the provided expression.
///
/// - `expr`: An optional value for the operation.
/// - `loc`: An optional source map location for the assignment.
fn emit_return(&mut self, expr: Option<Box<Expr>>, loc: Option<Span>) {
self.emit_worker(OpCode::Return, Some(OpArgs::OptExpr(expr)), loc);
}
/// Emits a Throw operation for the provided expression.
///
/// - `expr`: A value for the operation.
/// - `loc`: An optional source map location for the assignment.
fn emit_throw(&mut self, expr: Box<Expr>, loc: Option<Span>) {
self.emit_worker(OpCode::Throw, Some(OpArgs::OptExpr(Some(expr))), loc);
}
/// Emits an Endfinally operation. This is used to handle `finally` block
/// semantics.
fn emit_endfinally(&mut self) {
self.emit_worker(OpCode::Endfinally, None, None);
}
/// Emits an operation.
///
/// - `code`: The OpCode for the operation.
/// - `args`: The optional arguments for the operation.
fn emit_worker(&mut self, code: OpCode, args: Option<OpArgs>, loc: Option<Span>) {
if self.operations.is_none() {
self.operations = Some(Vec::new());
self.operation_args = Some(Vec::new());
self.operation_locs = Some(Vec::new());
}
if self.label_offsets.is_none() {
// mark entry point
let label = self.define_label();
self.mark_label(label);
}
debug_assert!(self.operations.is_some());
debug_assert_eq!(
self.operations.as_ref().unwrap().len(),
self.operation_args.as_ref().unwrap().len()
);
debug_assert_eq!(
self.operations.as_ref().unwrap().len(),
self.operation_locs.as_ref().unwrap().len()
);
self.operations.as_mut().unwrap().push(code);
self.operation_args.as_mut().unwrap().push(args);
self.operation_locs
.as_mut()
.unwrap()
.push(loc.unwrap_or(DUMMY_SP));
}
/// Builds the statements for the generator function body.
fn build_stmts(&mut self) -> Vec<Stmt> {
if let Some(ops) = self.operations.clone() {
for (op_index, _) in ops.iter().enumerate() {
self.write_operation(op_index);
}
self.flush_final_label(ops.len());
} else {
self.flush_final_label(0);
}
if let Some(clauses) = self.clauses.take() {
let label_expr = self.state.clone().make_member(quote_ident!("label"));
let switch_stmt = SwitchStmt {
span: DUMMY_SP,
discriminant: label_expr.into(),
cases: clauses,
};
return vec![Stmt::Switch(switch_stmt)];
}
if let Some(stmts) = self.stmts.take() {
return stmts;
}
Vec::new()
}
/// Flush the current label and advance to a new label.
fn flush_label(&mut self) {
if self.stmts.is_none() {
return;
}
self.append_label(!self.last_operation_was_abrupt);
self.last_operation_was_abrupt = false;
self.last_operation_was_completion = false;
self.label_number += 1;
}
/// Flush the final label of the generator function body.
fn flush_final_label(&mut self, op_index: usize) {
if self.is_final_label_reachable(op_index) {
self.try_enter_label(op_index);
self.with_block_stack = None;
self.write_return(None, None);
}
if self.stmts.is_some() && self.clauses.is_some() {
self.append_label(false);
}
self.update_label_expression();
}
/// Tests whether the final label of the generator function body is
/// reachable by user code.
fn is_final_label_reachable(&self, op_index: usize) -> bool {
// if the last operation was *not* a completion (return/throw) then
// the final label is reachable.
if !self.last_operation_was_completion {
return true;
}
// if there are no labels defined or referenced, then the final label is not
// reachable.
if self.label_offsets.is_none() || self.label_exprs.is_none() {
return false;
}
// if the label for this offset is referenced, then the final label
// is reachable.
for (label, label_offset) in self
.label_offsets
.as_ref()
.unwrap()
.iter()
.copied()
.enumerate()
{
if label_offset as usize == op_index
&& self.label_exprs.as_ref().unwrap().get(label).is_some()
{
return true;
}
}
false
}
/// Appends a case clause for the last label and sets the new label.
///
/// @param markLabelEnd Indicates that the transition between labels was a
/// fall-through from a previous case clause and the change in labels should
/// be reflected on the `state` object.
fn append_label(&mut self, mark_label_end: bool) {
if cfg!(debug_assertions) {
debug!(mark_label_end = mark_label_end, "append_label");
}
if self.clauses.is_none() {
self.clauses = Some(Default::default());
}
#[allow(clippy::manual_unwrap_or_default)]
let stmts = if let Some(mut stmts) = self.stmts.take() {
if self.with_block_stack.is_some() {
// The previous label was nested inside one or more `with`
// blocks, so we surround the statements in
// generated `with` blocks to create the same environment.
for (_i, with_block) in self
.with_block_stack
.as_ref()
.unwrap()
.iter()
.enumerate()
.rev()
{
let b = with_block.borrow();
let with_block = match &*b {
CodeBlock::With(v) => v,
_ => {
unreachable!()
}
};
stmts = vec![Stmt::With(WithStmt {
span: DUMMY_SP,
obj: Box::new(Expr::Ident(with_block.expression.clone())),
body: Box::new(Stmt::Block(BlockStmt {
span: DUMMY_SP,
stmts,
..Default::default()
})),
})];
}
}
if cfg!(debug_assertions) {
debug!(
"current_exception_block = {:?}",
self.current_exception_block
);
}
if let Some(current_exception_block) = self.current_exception_block.take() {
let b = current_exception_block.borrow();
let ExceptionBlock {
start_label,
catch_label,
finally_label,
end_label,
..
} = match &*b {
CodeBlock::Exception(v) => v,
_ => {
unreachable!()
}
};
let start_label = self.create_label(Some(*start_label));
let catch_label = self.create_label(*catch_label);
let finally_label = self.create_label(*finally_label);
let end_label = self.create_label(Some(*end_label));
stmts.insert(
0,
ExprStmt {
span: DUMMY_SP,
expr: CallExpr {
span: DUMMY_SP,
callee: self
.state
.clone()
.make_member(quote_ident!("trys"))
.make_member(quote_ident!("push"))
.as_callee(),
args: vec![ArrayLit {
span: DUMMY_SP,
elems: vec![
Some(start_label.as_arg()),
Some(catch_label.as_arg()),
Some(finally_label.as_arg()),
Some(end_label.as_arg()),
],
}
.as_arg()],
..Default::default()
}
.into(),
}
.into(),
);
}
if mark_label_end {
// The case clause for the last label falls through to this
// label, so we add an assignment statement to
// reflect the change in labels.
stmts.push(
ExprStmt {
span: DUMMY_SP,
expr: AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: self.state.clone().make_member(quote_ident!("label")).into(),
right: (self.label_number + 1).into(),
}
.into(),
}
.into(),
);
}
stmts
} else {
Default::default()
};
self.clauses.as_mut().unwrap().push(SwitchCase {
span: DUMMY_SP,
test: Some(self.label_number.into()),
cons: stmts,
});
}
#[tracing::instrument(skip(self))]
fn try_enter_label(&mut self, op_index: usize) {
if self.label_offsets.is_none() {
return;
}
for (label, label_offset) in self.label_offsets.clone().unwrap().into_iter().enumerate() {
if label_offset as usize == op_index {
self.flush_label();
if self.label_numbers.is_none() {
self.label_numbers = Some(Vec::new());
}
if let Some(v) = self
.label_numbers
.as_mut()
.unwrap()
.get_mut(self.label_number)
{
v.push(label);
} else {
if self.label_number >= self.label_numbers.as_ref().unwrap().len() {
self.label_numbers
.as_mut()
.unwrap()
.resize(self.label_number + 1, Vec::new());
}
self.label_numbers.as_mut().unwrap()[self.label_number] = vec![label];
}
}
}
}
/// Updates literal expressions for labels with actual label numbers.
fn update_label_expression(&mut self) {
if self.label_exprs.is_some() && self.label_numbers.is_some() {
for (label_number, labels) in self.label_numbers.as_ref().unwrap().iter().enumerate() {
for &label in labels {
let exprs = self.label_exprs.as_mut().unwrap().get_mut(label);
if let Some(exprs) = exprs {
for expr in exprs {
expr.value = label_number as _;
#[cfg(debug_assertions)]
debug!("Label {:?} = {:?} ({:?})", label, expr.value, expr.pos);
}
}
}
}
}
}
/// Tries to enter or leave a code block.
#[tracing::instrument(skip(self))]
fn try_enter_or_leave_block(&mut self, op_index: usize) {
if let Some(blocks) = &self.blocks {
while self.block_index < self.block_actions.as_ref().unwrap().len()
&& self.block_offsets.as_ref().unwrap()[self.block_index] <= op_index
{
#[cfg(debug_assertions)]
debug!("try_enter_or_leave_block: iter");
let block_index = self.block_index;
self.block_index += 1;
if cfg!(debug_assertions) {
debug!(block_index = block_index, "try_enter_or_leave_block")
}
//
let block = blocks[block_index].clone();
let block_action = self.block_actions.as_ref().unwrap()[block_index];
let b = block.borrow();
match &*b {
CodeBlock::Exception(_) => {
if block_action == BlockAction::Open {
self.exception_block_stack
.get_or_insert_with(Default::default)
.extend(self.current_exception_block.clone());
// https://github.com/swc-project/swc/issues/5913
if self.stmts.is_none() {
self.stmts = Some(Default::default());
}
#[cfg(debug_assertions)]
debug!("Current exception block: open = Some({:?})", block);
self.current_exception_block = Some(block.clone());
} else if block_action == BlockAction::Close {
self.current_exception_block =
self.exception_block_stack.as_mut().unwrap().pop();
#[cfg(debug_assertions)]
debug!(
"Current exception block: close = {:?}",
self.current_exception_block
);
}
}
CodeBlock::With(_) => {
if block_action == BlockAction::Open {
if self.with_block_stack.is_none() {
self.with_block_stack = Some(Default::default());
}
self.with_block_stack.as_mut().unwrap().push(block.clone());
} else if block_action == BlockAction::Close {
self.with_block_stack.as_mut().unwrap().pop();
}
}
_ => {}
}
}
}
}
/// Writes an operation as a statement to the current label's statement
/// list.
#[tracing::instrument(skip(self))]
fn write_operation(&mut self, op_index: usize) {
if cfg!(debug_assertions) {
debug!("Writing operation {}", op_index);
}
self.try_enter_label(op_index);
self.try_enter_or_leave_block(op_index);
// early termination, nothing else to process in this label
if self.last_operation_was_abrupt {
return;
}
self.last_operation_was_abrupt = false;
self.last_operation_was_completion = false;
let opcode = self.operations.as_ref().unwrap()[op_index];
if opcode == OpCode::Nop {
return;
} else if opcode == OpCode::Endfinally {
self.write_end_finally();
return;
}
let args = self.operation_args.as_mut().unwrap()[op_index]
.take()
.expect("failed to take operation arguments");
if opcode == OpCode::Statement {
let args = args.expect_stmt();
self.write_stmt(*args);
return;
}
let loc = self.operation_locs.as_ref().unwrap()[op_index];
match opcode {
OpCode::Assign => {
let args = args.expect_pat_and_expr();
self.write_assign(args.0, args.1, Some(loc));
}
OpCode::Break => {
let args = args.expect_label();
self.write_break(args, Some(loc));
}
OpCode::BreakWhenTrue => {
let args = args.expect_label_expr();
self.write_break_when_true(args.0, args.1, Some(loc));
}
OpCode::BreakWhenFalse => {
let args = args.expect_label_expr();
self.write_break_when_false(args.0, args.1, Some(loc));
}
OpCode::Yield => {
let args = args.expect_opt_expr();
self.write_yield(args, Some(loc));
}
OpCode::YieldStar => {
let args = args.expect_opt_expr().unwrap();
self.write_yield_star(args, Some(loc));
}
OpCode::Return => {
let args = args.expect_opt_expr();
self.write_return(args, Some(loc));
}
OpCode::Throw => {
let args = args.expect_opt_expr().unwrap();
self.write_throw(args, Some(loc));
}
_ => {}
}
}
/// Writes a statement to the current label's statement list.
fn write_stmt(&mut self, stmt: Stmt) {
if stmt.is_empty() {
return;
}
match self.stmts {
Some(ref mut stmts) => stmts.push(stmt),
None => self.stmts = Some(vec![stmt]),
}
}
/// Writes an Assign operation to the current label's statement list.
fn write_assign(&mut self, left: AssignTarget, right: Box<Expr>, op_loc: Option<Span>) {
self.write_stmt(
ExprStmt {
span: op_loc.unwrap_or(DUMMY_SP),
expr: AssignExpr {
span: DUMMY_SP,
op: op!("="),
left,
right,
}
.into(),
}
.into(),
)
}
/// Writes a Throw operation to the current label's statement list.
///
/// @param expr The value to throw
/// @param operationLocation The source map location for the operation.
fn write_throw(&mut self, expr: Box<Expr>, op_loc: Option<Span>) {
self.last_operation_was_abrupt = true;
self.last_operation_was_completion = true;
// let inst = self.create_instruction(Instruction::Return);
self.write_stmt(
ThrowStmt {
span: op_loc.unwrap_or(DUMMY_SP),
arg: expr,
}
.into(),
)
}
/// Writes a Return operation to the current label's statement list.
///
/// @param label The label for the Break.
/// @param operationLocation The source map location for the operation.
fn write_return(&mut self, expr: Option<Box<Expr>>, op_loc: Option<Span>) {
self.last_operation_was_abrupt = true;
self.last_operation_was_completion = true;
let inst = self.create_instruction(Instruction::Return);
self.write_stmt(
ReturnStmt {
span: op_loc.unwrap_or(DUMMY_SP),
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems: match expr {
Some(expr) => {
vec![Some(inst.as_arg()), Some(expr.as_arg())]
}
_ => {
vec![Some(inst.as_arg())]
}
},
}
.into(),
),
}
.into(),
)
}
/// Writes a Break operation to the current label's statement list.
///
/// @param label The label for the Break.
/// @param operationLocation The source map location for the operation.
fn write_break(&mut self, label: Label, op_loc: Option<Span>) {
self.last_operation_was_abrupt = true;
let inst = self.create_instruction(Instruction::Break);
let label = self.create_label(Some(label));
self.write_stmt(
ReturnStmt {
span: op_loc.unwrap_or(DUMMY_SP),
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems: vec![Some(inst.as_arg()), Some(label.as_arg())],
}
.into(),
),
}
.into(),
)
}
/// Writes a BreakWhenTrue operation to the current label's statement list.
///
/// @param label The label for the Break.
/// @param condition The condition for the Break.
/// @param operationLocation The source map location for the operation.
fn write_break_when_true(&mut self, label: Label, cond: Box<Expr>, op_loc: Option<Span>) {
let inst = self.create_instruction(Instruction::Break);
let label = self.create_label(Some(label));
self.write_stmt(
IfStmt {
span: DUMMY_SP,
test: cond,
cons: Box::new(Stmt::Return(ReturnStmt {
span: op_loc.unwrap_or(DUMMY_SP),
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems: vec![Some(inst.as_arg()), Some(label.as_arg())],
}
.into(),
),
})),
alt: None,
}
.into(),
)
}
/// Writes a BreakWhenFalse operation to the current label's statement list.
///
/// @param label The label for the Break.
/// @param condition The condition for the Break.
/// @param operationLocation The source map location for the operation.
fn write_break_when_false(&mut self, label: Label, cond: Box<Expr>, op_loc: Option<Span>) {
let inst = self.create_instruction(Instruction::Break);
let label = self.create_label(Some(label));
self.write_stmt(
IfStmt {
span: DUMMY_SP,
test: UnaryExpr {
span: DUMMY_SP,
op: op!("!"),
arg: cond,
}
.into(),
cons: Box::new(Stmt::Return(ReturnStmt {
span: op_loc.unwrap_or(DUMMY_SP),
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems: vec![Some(inst.as_arg()), Some(label.as_arg())],
}
.into(),
),
})),
alt: None,
}
.into(),
)
}
/// Writes a Yield operation to the current label's statement list.
///
/// - expr: The expression to yield.
/// - op_loc: The source map location for the operation.
fn write_yield(&mut self, expr: Option<Box<Expr>>, op_loc: Option<Span>) {
self.last_operation_was_abrupt = true;
let inst = self.create_instruction(Instruction::Yield);
let elems = match expr {
Some(expr) => {
vec![Some(inst.as_arg()), Some(expr.as_arg())]
}
None => {
vec![Some(inst.as_arg())]
}
};
self.write_stmt(
ReturnStmt {
span: op_loc.unwrap_or(DUMMY_SP),
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems,
}
.into(),
),
}
.into(),
);
}
/// Writes a YieldStar instruction to the current label's statement list.
///
/// - expr: The expression to yield.
/// - op_loc: The source map location for the operation.
fn write_yield_star(&mut self, expr: Box<Expr>, op_loc: Option<Span>) {
self.last_operation_was_abrupt = true;
let arg1 = self.create_instruction(Instruction::YieldStar);
self.write_stmt(
ReturnStmt {
span: op_loc.unwrap_or(DUMMY_SP),
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems: vec![Some(arg1.as_arg()), Some(expr.as_arg())],
}
.into(),
),
}
.into(),
)
}
/// Writes an Endfinally instruction to the current label's statement list.
fn write_end_finally(&mut self) {
self.last_operation_was_abrupt = true;
let arg = self.create_instruction(Instruction::Endfinally);
self.write_stmt(
ReturnStmt {
span: DUMMY_SP,
arg: Some(
ArrayLit {
span: DUMMY_SP,
elems: vec![Some(arg.as_arg())],
}
.into(),
),
}
.into(),
)
}
fn hoist_variable_declaration(&mut self, id: &Ident) {
self.hoisted_vars.push(VarDeclarator {
span: DUMMY_SP,
name: id.clone().into(),
init: None,
definite: Default::default(),
})
}
fn get_initialized_variables<'a>(
&self,
initializer: &'a mut VarDecl,
) -> Vec<&'a mut VarDeclarator> {
initializer
.decls
.iter_mut()
.filter(|v| v.init.is_some())
.collect()
}
fn create_temp_variable(&mut self) -> Ident {
let i = private_ident!("_");
self.hoisted_vars.push(VarDeclarator {
span: DUMMY_SP,
name: i.clone().into(),
init: None,
definite: Default::default(),
});
i
}
/// Returns `(target, this_arg)`
fn create_call_binding(
&mut self,
expr: Box<Expr>,
is_new_call: bool,
) -> (Box<Expr>, Box<Expr>) {
let mut callee = expr;
match &mut *callee {
Expr::Ident(..) => (
callee.clone(),
if is_new_call {
callee
} else {
Expr::undefined(DUMMY_SP)
},
),
Expr::Member(MemberExpr { obj, .. }) if !is_new_call => {
if obj.is_ident() {
let this_arg = obj.clone();
return (callee, this_arg);
}
let this_arg = self.create_temp_variable();
*obj = Box::new(obj.take().make_assign_to(op!("="), this_arg.clone().into()));
(callee, this_arg.into())
}
_ => {
if !is_new_call {
(callee, Expr::undefined(DUMMY_SP))
} else {
let this_arg = self.create_temp_variable();
let target = callee.make_assign_to(op!("="), this_arg.clone().into());
(Box::new(target), this_arg.into())
}
}
}
}
}
fn contains_yield<N>(node: &N) -> bool
where
N: VisitWith<YieldFinder>,
{
let mut v = YieldFinder { found: false };
node.visit_with(&mut v);
v.found
}
struct YieldFinder {
found: bool,
}
impl Visit for YieldFinder {
noop_visit_type!(fail);
fn visit_yield_expr(&mut self, _: &YieldExpr) {
self.found = true;
}
fn visit_arrow_expr(&mut self, f: &ArrowExpr) {
f.params.visit_with(self);
}
fn visit_function(&mut self, f: &Function) {
f.decorators.visit_with(self);
f.params.visit_with(self);
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub(super) struct Loc {
pos: BytePos,
value: i32,
}
/// Convert <invalid> to case number
struct InvalidToLit<'a> {
// Map from loc-id to stmt index
map: Option<&'a [Vec<Loc>]>,
}
impl VisitMut for InvalidToLit<'_> {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, e: &mut Expr) {
e.visit_mut_children_with(self);
if let Expr::Invalid(Invalid { span }) = e {
if span.lo != BytePos(0) && span.lo == span.hi {
if let Some(Loc { value, .. }) = self
.map
.iter()
.flat_map(|v| v.iter())
.flatten()
.find(|loc| loc.pos == span.lo)
{
*e = (*value as usize).into();
}
}
}
}
fn visit_mut_seq_expr(&mut self, e: &mut SeqExpr) {
e.visit_mut_children_with(self);
e.exprs.retain(|e| !e.is_invalid());
}
fn visit_mut_opt_expr_or_spread(&mut self, e: &mut Option<ExprOrSpread>) {
e.visit_mut_children_with(self);
if let Some(arg) = e {
if arg.expr.is_invalid() {
*e = None;
}
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/instanceof.rs | Rust | use swc_common::{util::take::Take, Span, Spanned};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{helper, perf::Parallel};
use swc_ecma_utils::ExprFactory;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
/// `@babel/plugin-transform-instanceof`
///
///
///
/// # Example
///
/// ## In
///
/// ```js
/// foo instanceof Bar;
/// ```
///
/// ## Out
///
/// ```js
/// function _instanceof(left, right) {
/// if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
/// return !!right[Symbol.hasInstance](left);
/// } else {
/// return left instanceof right;
/// }
/// }
///
/// _instanceof(foo, Bar);
/// ```
pub fn instance_of() -> impl Pass {
visit_mut_pass(InstanceOf)
}
struct InstanceOf;
impl Parallel for InstanceOf {
fn merge(&mut self, _: Self) {}
fn create(&self) -> Self {
InstanceOf
}
}
#[swc_trace]
impl VisitMut for InstanceOf {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Expr::Bin(BinExpr {
span,
left,
op: op!("instanceof"),
right,
}) = expr
{
let instanceof_span = Span {
lo: left.span_hi(),
hi: right.span_lo(),
};
*expr = CallExpr {
span: *span,
callee: helper!(instanceof_span, instanceof),
args: vec![left.take().as_arg(), right.take().as_arg()],
..Default::default()
}
.into();
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/lib.rs | Rust | #![allow(clippy::vec_box)]
#![allow(clippy::boxed_local)]
use serde::Deserialize;
use swc_common::{comments::Comments, Mark};
use swc_ecma_ast::Pass;
use swc_ecma_compat_common::regexp::{self, regexp};
pub use self::{
arrow::arrow, block_scoped_fn::block_scoped_functions, block_scoping::block_scoping,
classes::classes, computed_props::computed_properties, destructuring::destructuring,
duplicate_keys::duplicate_keys, for_of::for_of, function_name::function_name,
instanceof::instance_of, new_target::new_target, object_super::object_super,
parameters::parameters, shorthand_property::shorthand, spread::spread,
sticky_regex::sticky_regex, template_literal::template_literal, typeof_symbol::typeof_symbol,
};
mod arrow;
mod block_scoped_fn;
mod block_scoping;
pub mod classes;
pub mod computed_props;
pub mod destructuring;
mod duplicate_keys;
pub mod for_of;
mod function_name;
pub mod generator;
mod instanceof;
pub mod new_target;
mod object_super;
pub mod parameters;
pub mod regenerator;
mod shorthand_property;
pub mod spread;
mod sticky_regex;
pub mod template_literal;
mod typeof_symbol;
fn exprs(unresolved_mark: Mark) -> impl Pass {
(
arrow(unresolved_mark),
duplicate_keys(),
sticky_regex(),
instance_of(),
typeof_symbol(),
)
}
/// Compiles es2015 to es5.
///
/// # Parameters
///
/// ## `unresolved_mark`
///
/// Used to generate `require` calls.
/// See the documentation of [regenerator](self::regenerator::regenerator) for
/// more details.
pub fn es2015<C>(unresolved_mark: Mark, comments: Option<C>, c: Config) -> impl Pass
where
C: Comments + Clone,
{
(
(
regexp(regexp::Config {
dot_all_regex: false,
has_indices: false,
lookbehind_assertion: false,
named_capturing_groups_regex: false,
sticky_regex: true,
unicode_property_regex: false,
unicode_regex: true,
unicode_sets_regex: false,
}),
block_scoped_functions(),
template_literal(c.template_literal),
classes(c.classes),
new_target(),
spread(c.spread),
),
// https://github.com/Microsoft/TypeScript/issues/5441
if !c.typescript {
Some(object_super())
} else {
None
},
shorthand(),
function_name(),
for_of(c.for_of),
// Should come before parameters
// See: https://github.com/swc-project/swc/issues/1036
parameters(c.parameters, unresolved_mark),
(
exprs(unresolved_mark),
computed_properties(c.computed_props),
destructuring(c.destructuring),
block_scoping(unresolved_mark),
generator::generator(unresolved_mark, comments.clone()),
),
)
}
#[derive(Debug, Clone, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
#[serde(default)]
pub classes: classes::Config,
#[serde(flatten)]
pub computed_props: computed_props::Config,
#[serde(flatten)]
pub for_of: for_of::Config,
#[serde(flatten)]
pub destructuring: destructuring::Config,
#[serde(flatten)]
pub spread: spread::Config,
#[serde(default)]
pub regenerator: regenerator::Config,
#[serde(default)]
pub template_literal: template_literal::Config,
#[serde(default)]
pub parameters: parameters::Config,
#[serde(default)]
pub typescript: bool,
}
#[cfg(test)]
mod tests {
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_testing::{test, test_exec};
use super::*;
test!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
),
issue_169,
r#"
export class Foo {
func(a, b = Date.now()) {
return {a};
}
}
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
),
issue_189,
r#"
class HomePage extends React.Component {}
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
),
issue_227,
"export default function fn1(...args) {
fn2(...args);
}"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| (
block_scoped_functions(),
resolver(Mark::new(), Mark::new(), false)
),
issue_271,
"
function foo(scope) {
scope.startOperation = startOperation;
function startOperation(operation) {
scope.agentOperation = operation;
}
}
"
);
// test!(
// ::swc_ecma_parser::Syntax::default(),
// |_| (
// resolver(),
// class_properties(),
// // Optional::new(compat::es2018(), target <= EsVersion::Es2018),
// // Optional::new(compat::es2017(), target <= EsVersion::Es2017),
// // Optional::new(compat::es2016(), target <= EsVersion::Es2016),
// // Optional::new(compat::es2015(Mark::fresh(Mark::root()),
// Default::default()), target <= EsVersion::Es2015), //
// Optional::new(compat::es3(), target <= EsVersion::Es3),
// hygiene(), fixer(),
// ),
// issue_405,
// "function Quadtree$1(x, y, x0, y0, x1, y1) {
// this._x = x;
// this._y = y;
// this._x0 = x0;
// this._y0 = y0;
// this._x1 = x1;
// this._y1 = y1;
// this._root = undefined;
// }
// ",
// ""
// );
test!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
),
issue_413,
r#"
export const getBadgeBorderRadius = (text, color) => {
return (text && style) || {}
}"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
),
issue_400_1,
"class A {
constructor() {
this.a_num = 10;
}
print() {
expect(this.a_num).toBe(10);
}
}
class B extends A {
constructor(num) {
super();
this.b_num = num;
}
print() {
expect(this.b_num).toBe(20);
super.print();
}
}
"
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
),
issue_400_2,
"class A {
constructor() {
this.a_num = 10;
}
print() {
expect(this.a_num).toBe(10);
}
}
class B extends A {
constructor(num) {
super();
this.b_num = num;
}
print() {
expect(this.b_num).toBe(20);
super.print();
}
}
return new B(20).print()"
);
test!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
),
issue_1660_1,
"
console.log(class {run(){}});
"
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
),
issue_2682,
"class MyObject extends null {
constructor() {
return Object.create(new.target.prototype);
}
}
var obj = new MyObject();
expect(obj.constructor).toBe(MyObject);
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Config {
classes: classes::Config {
set_class_methods: true,
..classes::Config::default()
},
..Config::default()
}
),
should_escape_keyword_in_method,
r#"
export class Foo {
let() {}
}
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|t| es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Config {
..Default::default()
}
),
issue_8871,
r#"
const x = "</" + "script>";
const y = "<\/script>";
const z = "\/\/ \\";
export { x, y, z };
"#
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/new_target.rs | Rust | use std::{borrow::Cow, mem};
use swc_common::{pass::CompilerPass, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::perf::{should_work, Check};
use swc_ecma_utils::{private_ident, quote_ident, ExprFactory};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith,
};
use swc_trace_macro::swc_trace;
pub fn new_target() -> impl Pass {
visit_mut_pass(NewTarget {
ctx: Ctx::Constructor,
})
}
struct NewTarget {
ctx: Ctx,
}
enum Ctx {
Constructor,
Method,
Function(Ident),
}
impl NewTarget {
fn visit_mut_method<T: VisitMutWith<Self>>(&mut self, c: &mut T) {
let old = mem::replace(&mut self.ctx, Ctx::Method);
c.visit_mut_with(self);
self.ctx = old;
}
}
#[swc_trace]
impl VisitMut for NewTarget {
noop_visit_mut_type!(fail);
fn visit_mut_class_method(&mut self, c: &mut ClassMethod) {
c.key.visit_mut_with(self);
self.visit_mut_method(&mut c.function)
}
fn visit_mut_constructor(&mut self, c: &mut Constructor) {
let old = mem::replace(&mut self.ctx, Ctx::Constructor);
c.visit_mut_children_with(self);
self.ctx = old;
}
fn visit_mut_expr(&mut self, e: &mut Expr) {
e.visit_mut_children_with(self);
if let Expr::MetaProp(MetaPropExpr {
kind: MetaPropKind::NewTarget,
span,
}) = e
{
let this_ctor = |span| {
ThisExpr { span }
.make_member(quote_ident!("constructor"))
.into()
};
match &self.ctx {
Ctx::Constructor => *e = this_ctor(*span),
Ctx::Method => *e = *Expr::undefined(DUMMY_SP),
Ctx::Function(i) => {
*e = CondExpr {
span: *span,
// this instanceof Foo
test: BinExpr {
span: DUMMY_SP,
op: op!("instanceof"),
left: Box::new(Expr::This(ThisExpr { span: DUMMY_SP })),
right: Box::new(Expr::Ident(i.clone())),
}
.into(),
cons: Box::new(this_ctor(DUMMY_SP)),
// void 0
alt: Expr::undefined(DUMMY_SP),
}
.into()
}
}
}
}
fn visit_mut_fn_decl(&mut self, f: &mut FnDecl) {
// Ensure that `f` contains `new.target`.
if !should_work::<ShouldWork, _>(&*f) {
return;
}
let old = mem::replace(&mut self.ctx, Ctx::Function(f.ident.clone()));
f.visit_mut_children_with(self);
self.ctx = old;
}
fn visit_mut_fn_expr(&mut self, f: &mut FnExpr) {
// Ensure that `f` contains `new.target`.
if !should_work::<ShouldWork, _>(&*f) {
return;
}
let i = f
.ident
.get_or_insert_with(|| private_ident!("_target"))
.clone();
let old = mem::replace(&mut self.ctx, Ctx::Function(i));
f.visit_mut_children_with(self);
self.ctx = old;
}
fn visit_mut_method_prop(&mut self, m: &mut MethodProp) {
m.key.visit_mut_with(self);
self.visit_mut_method(&mut m.function)
}
fn visit_mut_getter_prop(&mut self, m: &mut GetterProp) {
m.key.visit_mut_with(self);
self.visit_mut_method(&mut m.body)
}
fn visit_mut_setter_prop(&mut self, m: &mut SetterProp) {
m.key.visit_mut_with(self);
self.visit_mut_method(&mut m.body)
}
}
impl CompilerPass for NewTarget {
fn name(&self) -> Cow<'static, str> {
Cow::Borrowed("new-target")
}
}
#[derive(Default)]
struct ShouldWork {
found: bool,
}
impl Visit for ShouldWork {
noop_visit_type!(fail);
fn visit_meta_prop_expr(&mut self, n: &MetaPropExpr) {
if let MetaPropExpr {
kind: MetaPropKind::NewTarget,
..
} = n
{
self.found = true;
}
}
}
impl Check for ShouldWork {
fn should_handle(&self) -> bool {
self.found
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/object_super.rs | Rust | use std::iter;
use swc_common::{util::take::Take, Span, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::helper;
use swc_ecma_utils::{
alias_ident_for, is_rest_arguments, prepend_stmt, private_ident, quote_ident, ExprFactory,
};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
struct ObjectSuper {
extra_vars: Vec<Ident>,
}
pub fn object_super() -> impl Pass {
visit_mut_pass(ObjectSuper {
extra_vars: Vec::new(),
})
}
#[swc_trace]
impl VisitMut for ObjectSuper {
noop_visit_mut_type!(fail);
fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem>) {
n.visit_mut_children_with(self);
if !self.extra_vars.is_empty() {
prepend_stmt(
n,
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: false,
decls: self
.extra_vars
.take()
.into_iter()
.map(|v| VarDeclarator {
span: DUMMY_SP,
name: v.into(),
init: None,
definite: false,
})
.collect(),
..Default::default()
}
.into(),
);
}
}
fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
stmts.visit_mut_children_with(self);
if !self.extra_vars.is_empty() {
prepend_stmt(
stmts,
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: self
.extra_vars
.drain(..)
.map(|v| VarDeclarator {
span: DUMMY_SP,
name: v.into(),
init: None,
definite: false,
})
.collect(),
..Default::default()
}
.into(),
);
}
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Expr::Object(ObjectLit { span: _, props }) = expr {
let mut replacer = SuperReplacer {
obj: None,
vars: Vec::new(),
};
for prop_or_spread in props.iter_mut() {
if let PropOrSpread::Prop(ref mut prop) = prop_or_spread {
if let Prop::Method(MethodProp { key: _, function }) = &mut **prop {
function.visit_mut_with(&mut replacer);
if !replacer.vars.is_empty() {
if let Some(BlockStmt { span: _, stmts, .. }) = &mut function.body {
prepend_stmt(
stmts,
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: false,
decls: replacer
.vars
.drain(..)
.map(|v| VarDeclarator {
span: DUMMY_SP,
name: v.into(),
init: None,
definite: false,
})
.collect(),
..Default::default()
}
.into(),
);
}
}
}
}
}
if let Some(obj) = replacer.obj {
*expr = AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: obj.clone().into(),
right: Box::new(expr.take()),
}
.into();
self.extra_vars.push(obj);
}
}
}
}
struct SuperReplacer {
obj: Option<Ident>,
vars: Vec<Ident>,
}
#[swc_trace]
impl VisitMut for SuperReplacer {
noop_visit_mut_type!(fail);
fn visit_mut_object_lit(&mut self, obj: &mut ObjectLit) {
for prop_or_spread in obj.props.iter_mut() {
if let PropOrSpread::Prop(prop) = prop_or_spread {
match &mut **prop {
Prop::Method(MethodProp { key, .. })
| Prop::Getter(GetterProp { key, .. })
| Prop::Setter(SetterProp { key, .. }) => key.visit_mut_with(self),
Prop::KeyValue(KeyValueProp { key, value }) => {
key.visit_mut_with(self);
if !(value.is_fn_expr() || value.is_class()) {
value.visit_mut_with(self)
}
}
Prop::Shorthand(_) | Prop::Assign(_) => (),
}
}
}
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
self.visit_mut_super_member_call(expr);
self.visit_mut_super_member_set(expr);
self.visit_mut_super_member_get(expr);
expr.visit_mut_children_with(self)
}
}
#[swc_trace]
impl SuperReplacer {
fn get_obj_ref(&mut self) -> Ident {
if let Some(obj) = &self.obj {
obj.clone()
} else {
let ident = private_ident!("_obj");
self.obj = Some(ident.clone());
ident
}
}
fn get_proto(&mut self) -> ExprOrSpread {
CallExpr {
span: DUMMY_SP,
callee: helper!(get_prototype_of),
args: vec![self.get_obj_ref().as_arg()],
..Default::default()
}
.as_arg()
}
// .a -> "a"
fn normalize_computed_expr(&mut self, prop: &mut SuperProp) -> Box<Expr> {
match prop.take() {
SuperProp::Ident(IdentName {
sym: value, span, ..
}) => Lit::Str(Str {
raw: None,
value,
span,
})
.into(),
SuperProp::Computed(ComputedPropName { expr, .. }) => expr,
}
}
/// # In
/// ```js
/// super.foo(a)
/// ```
/// # out
/// ```js
/// _get(_get_prototype_of(Clazz.prototype), 'foo', this).call(this, a)
/// ```
fn visit_mut_super_member_call(&mut self, n: &mut Expr) {
if let Expr::Call(CallExpr {
callee: Callee::Expr(callee_expr),
args,
..
}) = n
{
if let Expr::SuperProp(SuperPropExpr {
obj: Super { span: super_token },
prop,
..
}) = &mut **callee_expr
{
let prop = self.normalize_computed_expr(prop);
let callee =
SuperReplacer::super_to_get_call(self.get_proto(), *super_token, prop.as_arg());
let this = ThisExpr { span: DUMMY_SP }.as_arg();
if args.len() == 1 && is_rest_arguments(&args[0]) {
*n = CallExpr {
span: DUMMY_SP,
callee: MemberExpr {
span: DUMMY_SP,
obj: Box::new(callee),
prop: quote_ident!("apply").into(),
}
.as_callee(),
args: iter::once(this)
.chain(iter::once({
let mut arg = args.pop().unwrap();
arg.spread = None;
arg
}))
.collect(),
..Default::default()
}
.into();
return;
}
*n = CallExpr {
span: DUMMY_SP,
callee: MemberExpr {
span: DUMMY_SP,
obj: Box::new(callee),
prop: MemberProp::Ident(quote_ident!("call")),
}
.as_callee(),
args: iter::once(this).chain(args.take()).collect(),
..Default::default()
}
.into();
}
}
}
/// # In
/// ```js
/// super.foo = bar
/// # out
/// ```js
/// _set(_get_prototype_of(_obj), "foo", bar, this, true)
/// ```
fn visit_mut_super_member_set(&mut self, n: &mut Expr) {
match n {
Expr::Update(UpdateExpr {
arg, op, prefix, ..
}) => {
if let Expr::SuperProp(SuperPropExpr {
obj: Super { span: super_token },
prop,
..
}) = &mut **arg
{
let op = match op {
op!("++") => op!("+="),
op!("--") => op!("-="),
};
*n = self.super_to_set_call(*super_token, true, prop, op, 1.0.into(), *prefix);
}
}
Expr::Assign(AssignExpr {
span,
left,
op,
right,
}) => {
if let AssignTarget::Simple(SimpleAssignTarget::SuperProp(SuperPropExpr {
obj: Super { span: super_token },
prop,
..
})) = left
{
*n =
self.super_to_set_call(*super_token, false, prop, *op, right.take(), false);
return;
}
left.visit_mut_children_with(self);
*n = AssignExpr {
span: *span,
left: left.take(),
op: *op,
right: right.take(),
}
.into();
}
_ => {}
}
}
/// # In
/// ```js
/// super.foo
/// ```
/// # out
/// ```js
/// _get(_get_prototype_of(Clazz.prototype), 'foo', this)
/// ```
fn visit_mut_super_member_get(&mut self, n: &mut Expr) {
if let Expr::SuperProp(SuperPropExpr {
obj: Super {
span: super_token, ..
},
prop,
..
}) = n
{
let prop = self.normalize_computed_expr(prop);
*n = SuperReplacer::super_to_get_call(self.get_proto(), *super_token, prop.as_arg());
}
}
fn super_to_get_call(proto: ExprOrSpread, super_token: Span, prop: ExprOrSpread) -> Expr {
CallExpr {
span: super_token,
callee: helper!(get),
args: vec![proto, prop, ThisExpr { span: super_token }.as_arg()],
..Default::default()
}
.into()
}
fn to_bin_expr(left: Box<Expr>, op: AssignOp, rhs: Box<Expr>) -> BinExpr {
BinExpr {
span: DUMMY_SP,
left,
op: op.to_update().unwrap(),
right: rhs,
}
}
fn call_set_helper(
&mut self,
super_token: Span,
prop: ExprOrSpread,
rhs: ExprOrSpread,
) -> Expr {
CallExpr {
span: super_token,
callee: helper!(set),
args: vec![
self.get_proto(),
prop,
rhs,
ThisExpr { span: super_token }.as_arg(),
// strict
true.as_arg(),
],
..Default::default()
}
.into()
}
fn super_to_set_call(
&mut self,
super_token: Span,
is_update: bool,
prop: &mut SuperProp,
op: AssignOp,
rhs: Box<Expr>,
prefix: bool,
) -> Expr {
let computed = match prop {
SuperProp::Ident(_) => false,
SuperProp::Computed(_) => true,
};
let mut prop = self.normalize_computed_expr(prop);
match op {
op!("=") => self.call_set_helper(super_token, prop.as_arg(), rhs.as_arg()),
_ => {
let left = Box::new(SuperReplacer::super_to_get_call(
self.get_proto(),
super_token,
if computed {
let ref_ident = alias_ident_for(&rhs, "_ref").into_private();
self.vars.push(ref_ident.clone());
*prop = AssignExpr {
span: DUMMY_SP,
left: ref_ident.clone().into(),
op: op!("="),
right: prop.take(),
}
.into();
ref_ident.as_arg()
} else {
prop.clone().as_arg()
},
));
if is_update {
if prefix {
self.call_set_helper(
super_token,
prop.as_arg(),
SuperReplacer::to_bin_expr(
UnaryExpr {
span: DUMMY_SP,
op: op!(unary, "+"),
arg: left,
}
.into(),
op,
rhs,
)
.as_arg(),
)
} else {
let update_ident = alias_ident_for(&rhs, "_super").into_private();
self.vars.push(update_ident.clone());
SeqExpr {
span: DUMMY_SP,
exprs: vec![
Box::new(
self.call_set_helper(
super_token,
prop.as_arg(),
SuperReplacer::to_bin_expr(
Box::new(
AssignExpr {
span: DUMMY_SP,
left: update_ident.clone().into(),
op: op!("="),
right: Box::new(Expr::Unary(UnaryExpr {
span: DUMMY_SP,
op: op!(unary, "+"),
arg: left,
})),
}
.into(),
),
op,
rhs,
)
.as_arg(),
),
),
Box::new(Expr::Ident(update_ident)),
],
}
.into()
}
} else {
self.call_set_helper(
super_token,
prop.as_arg(),
SuperReplacer::to_bin_expr(left, op, rhs).as_arg(),
)
}
}
}
}
}
#[cfg(test)]
mod tests {
use swc_common::Mark;
use swc_ecma_parser::{EsSyntax, Syntax};
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_testing::test;
use super::*;
use crate::{function_name, shorthand};
test!(
::swc_ecma_parser::Syntax::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_super(),
shorthand(),
function_name(),
)
},
get,
"let obj = {
a(){
let c = super.x;
}
}"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| {
(
resolver(Mark::new(), Mark::new(), false),
object_super(),
shorthand(),
function_name(),
)
},
call,
"let obj = {
a(){
super.y(1,2,3);
}
}"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| {
(
resolver(Mark::new(), Mark::new(), false),
object_super(),
shorthand(),
function_name(),
)
},
set,
"let obj = {
a(){
super.x = 1;
}
}"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| {
(
resolver(Mark::new(), Mark::new(), false),
object_super(),
shorthand(),
function_name(),
)
},
nest,
"let obj = {
b(){
super.bar()
let o = {
d(){
super.d()
}
}
},
}"
);
test!(
Syntax::Es(EsSyntax {
allow_super_outside_method: true,
..Default::default()
}),
|_| {
(
resolver(Mark::new(), Mark::new(), false),
object_super(),
shorthand(),
function_name(),
)
},
do_not_transform,
"let outer = {
b(){
let inner = {
d:function d(){
super.d() // should not transform
}
}
},
}"
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/parameters.rs | Rust | use std::mem;
use arrayvec::ArrayVec;
use serde::Deserialize;
use swc_common::{util::take::Take, Mark, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
// use swc_ecma_transforms_base::perf::Parallel;
// use swc_ecma_transforms_macros::parallel;
use swc_ecma_utils::{
function::{init_this, FnEnvHoister},
member_expr, prepend_stmt, prepend_stmts, private_ident, quote_ident, ExprFactory,
};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
use tracing::trace;
pub fn parameters(c: Config, unresolved_mark: Mark) -> impl 'static + Pass {
let unresolved_ctxt = SyntaxContext::empty().apply_mark(unresolved_mark);
visit_mut_pass(Params {
c,
unresolved_ctxt,
hoister: FnEnvHoister::new(unresolved_ctxt),
..Default::default()
})
}
#[derive(Default)]
struct Params {
/// Used to store `this, in case if `arguments` is used and we should
/// transform an arrow expression to a function expression.
hoister: FnEnvHoister,
unresolved_ctxt: SyntaxContext,
in_subclass: bool,
in_prop: bool,
c: Config,
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
#[serde(default)]
pub ignore_function_length: bool,
}
// impl Parallel for Params {
// fn create(&self) -> Self {
// Params {
// state: Default::default(),
// c: self.c,
// }
// }
// fn merge(&mut self, other: Self) {
// self.state.merge(other.state);
// }
// fn after_stmts(&mut self, stmts: &mut Vec<Stmt>) {
// let decls = self.state.take().to_stmt();
// if let Some(decls) = decls {
// prepend(stmts, decls)
// }
// }
// fn after_module_items(&mut self, stmts: &mut Vec<ModuleItem>) {
// let decls = self.state.take().to_stmt();
// if let Some(decls) = decls {
// prepend(stmts, ModuleItem::Stmt(decls))
// }
// }
// }
#[swc_trace]
impl Params {
fn visit_mut_fn_like(&mut self, ps: &mut Vec<Param>, body: &mut BlockStmt, is_setter: bool) {
let mut params = Vec::new();
let mut decls = Vec::new();
let mut loose_stmt = Vec::new();
let mut unpack_rest = None;
let mut decls_after_unpack = Vec::new();
let mut after_default = false;
for (i, param) in ps.drain(..).enumerate() {
let span = param.span();
match param.pat {
Pat::Ident(..) => {
if after_default && !self.c.ignore_function_length {
decls.push(VarDeclarator {
span,
name: param.pat,
init: Some(Box::new(check_arg_len_or_undef(i))),
definite: false,
})
} else {
params.push(param)
}
}
Pat::Array(..) | Pat::Object(..) => {
if after_default && !self.c.ignore_function_length {
decls.push(VarDeclarator {
span,
name: param.pat,
init: Some(Box::new(check_arg_len_or_undef(i))),
definite: false,
})
} else {
let binding = private_ident!(span, "param");
params.push(Param {
pat: binding.clone().into(),
..param
});
let decl = VarDeclarator {
span,
name: param.pat,
init: Some(binding.into()),
definite: false,
};
if self.c.ignore_function_length {
loose_stmt.push(
VarDecl {
span,
kind: VarDeclKind::Let,
decls: vec![decl],
declare: false,
..Default::default()
}
.into(),
)
} else {
decls.push(decl)
}
}
}
Pat::Assign(AssignPat { left, right, .. }) => {
// arguments.length will always be 1 in setter
if !(self.c.ignore_function_length || is_setter) {
after_default = true;
// access non-existent element in `arguments` is expensive
decls.push(VarDeclarator {
span,
name: *left,
init: Some(
CondExpr {
span,
test: Box::new(
BinExpr {
left: Box::new(check_arg_len(i)),
op: op!("&&"),
right: Box::new(Expr::Bin(BinExpr {
left: make_arg_nth(i).into(),
op: op!("!=="),
right: Expr::undefined(DUMMY_SP),
span: DUMMY_SP,
})),
span,
}
.into(),
),
cons: make_arg_nth(i).into(),
alt: right,
}
.into(),
),
definite: false,
})
} else if let Pat::Ident(ident) = left.as_ref() {
params.push(Param {
span,
pat: ident.clone().into(),
decorators: Vec::new(),
});
loose_stmt.push(
IfStmt {
span,
test: BinExpr {
span: DUMMY_SP,
left: Box::new(Ident::from(ident).into()),
op: op!("==="),
right: Expr::undefined(DUMMY_SP),
}
.into(),
cons: Box::new(Stmt::Expr(ExprStmt {
span,
expr: AssignExpr {
span,
left: left.try_into().unwrap(),
op: op!("="),
right,
}
.into(),
})),
alt: None,
}
.into(),
)
} else {
let binding = private_ident!(span, "param");
params.push(Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: binding.clone().into(),
});
loose_stmt.push(
VarDecl {
span,
kind: VarDeclKind::Let,
decls: vec![VarDeclarator {
span,
name: *left,
init: Some(Box::new(Expr::Cond(CondExpr {
span,
test: Box::new(Expr::Bin(BinExpr {
span: DUMMY_SP,
left: Box::new(Expr::Ident(binding.clone())),
op: op!("==="),
right: Expr::undefined(DUMMY_SP),
})),
cons: right,
alt: Box::new(Expr::Ident(binding)),
}))),
definite: false,
}],
declare: false,
..Default::default()
}
.into(),
)
}
}
Pat::Rest(RestPat { arg, .. }) => {
// Inject a for statement
//
// for(var _len = arguments.length, a1 = new Array(_len), _key = 0; _key <
// _len; _key++){
// a1[_key] = arguments[_key];
// }
assert!(unpack_rest.is_none());
// TODO: Optimize (use `arguments` instead of rest argument)
let mark = Mark::fresh(Mark::root());
let idx_ident =
quote_ident!(SyntaxContext::empty().apply_mark(mark), span, "_key");
let len_ident =
quote_ident!(SyntaxContext::empty().apply_mark(mark), span, "_len");
let arg = match *arg {
Pat::Ident(ident) => ident.into(),
arg => {
let tmp_ident =
quote_ident!(SyntaxContext::empty().apply_mark(mark), span, "_tmp");
decls_after_unpack.push(VarDeclarator {
span: DUMMY_SP,
name: arg,
init: Some(Box::new(tmp_ident.clone().into())),
definite: false,
});
tmp_ident
}
};
let make_minus_i = |ident: &Ident, min_zero: bool| -> Expr {
if i == 0 {
// `len`
ident.clone().into()
} else {
// `len - $i`
let bin: Expr = BinExpr {
span,
left: ident.clone().into(),
op: op!(bin, "-"),
right: Lit::Num(Number {
span,
value: i as f64,
raw: None,
})
.into(),
}
.into();
if !min_zero {
return bin;
}
CondExpr {
span,
test: Box::new(
BinExpr {
span,
left: Box::new(len_ident.clone().into()),
op: op!(">"),
right: Lit::Num(Number {
span,
value: i as _,
raw: None,
})
.into(),
}
.into(),
),
cons: Box::new(bin),
alt: 0.into(),
}
.into()
}
};
unpack_rest = Some(
ForStmt {
span,
init: Some(
VarDecl {
kind: VarDeclKind::Var,
span,
decls: vec![
// _len = arguments.length - i
VarDeclarator {
span,
name: len_ident.clone().into(),
init: Some(
member_expr!(
Default::default(),
span,
arguments.length
)
.into(),
),
definite: false,
},
// a1 = new Array(_len - $i)
VarDeclarator {
span,
name: arg.clone().into(),
init: Some(Box::new(Expr::New(NewExpr {
span,
callee: Box::new(
quote_ident!(self.unresolved_ctxt, "Array")
.into(),
),
args: Some(vec![{
// `len` or `len - $i`
make_minus_i(&len_ident, true).as_arg()
}]),
..Default::default()
}))),
definite: false,
},
// _key = 0
VarDeclarator {
span,
name: idx_ident.clone().into(),
init: Some(Box::new(Expr::Lit(Lit::Num(Number {
span,
value: i as f64,
raw: None,
})))),
definite: false,
},
],
declare: false,
..Default::default()
}
.into(),
),
// `_key < _len`
test: Some(
BinExpr {
span,
left: Box::new(idx_ident.clone().into()),
op: op!("<"),
right: Box::new(len_ident.clone().into()),
}
.into(),
),
// _key++
update: Some(
UpdateExpr {
span,
op: op!("++"),
prefix: false,
arg: Box::new(idx_ident.clone().into()),
}
.into(),
),
body: Box::new(Stmt::Block(BlockStmt {
span: DUMMY_SP,
stmts: vec![{
let prop = Box::new(Expr::Ident(idx_ident.clone()));
// a1[_key - i] = arguments[_key];
AssignExpr {
span,
left: arg
.computed_member(make_minus_i(&idx_ident, false))
.into(),
op: op!("="),
right: Box::new(
MemberExpr {
span: DUMMY_SP,
obj: Box::new(
quote_ident!(
Default::default(),
span,
"arguments"
)
.into(),
),
prop: MemberProp::Computed(ComputedPropName {
span,
expr: prop,
}),
}
.into(),
),
}
.into_stmt()
}],
..Default::default()
})),
}
.into(),
)
}
_ => unreachable!(),
}
}
let mut iter: ArrayVec<_, 3> = Default::default();
if !decls.is_empty() {
iter.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Let,
decls,
declare: false,
..Default::default()
}
.into(),
)
}
iter.extend(unpack_rest);
if !decls_after_unpack.is_empty() {
iter.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Let,
decls: decls_after_unpack,
declare: false,
..Default::default()
}
.into(),
);
}
if (is_setter || self.c.ignore_function_length) && !loose_stmt.is_empty() {
loose_stmt.extend(iter);
prepend_stmts(&mut body.stmts, loose_stmt.into_iter());
} else {
prepend_stmts(&mut body.stmts, iter.into_iter());
};
*ps = params;
}
}
#[swc_trace]
impl VisitMut for Params {
noop_visit_mut_type!(fail);
// generally speaking, there won't be class field in here, but Safari 14.1
// still has bugs in parameters
fn visit_mut_class_prop(&mut self, prop: &mut ClassProp) {
prop.key.visit_mut_children_with(self);
let old_in_prop = self.in_prop;
self.in_prop = !prop.is_static;
prop.value.visit_mut_with(self);
self.in_prop = old_in_prop;
}
fn visit_mut_class_method(&mut self, m: &mut ClassMethod) {
if let MethodKind::Setter = m.kind {
let f = &mut m.function;
if f.body.is_none() {
return;
}
let old_in_subclass = self.in_subclass;
let old_in_prop = self.in_prop;
self.in_subclass = false;
self.in_prop = false;
f.visit_mut_children_with(self);
let mut body = f.body.take().unwrap();
self.visit_mut_fn_like(&mut f.params, &mut body, true);
f.body = Some(body);
self.in_subclass = old_in_subclass;
self.in_prop = old_in_prop;
} else {
m.visit_mut_children_with(self);
}
}
// same for private prop
fn visit_mut_private_prop(&mut self, prop: &mut PrivateProp) {
let old_in_prop = self.in_prop;
self.in_prop = !prop.is_static;
prop.value.visit_mut_with(self);
self.in_prop = old_in_prop;
}
fn visit_mut_block_stmt_or_expr(&mut self, body: &mut BlockStmtOrExpr) {
let old_rep = self.hoister.take();
body.visit_mut_children_with(self);
let decls = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(decls) = decls {
if let BlockStmtOrExpr::Expr(v) = body {
let mut stmts = Vec::new();
prepend_stmt(&mut stmts, decls);
stmts.push(
ReturnStmt {
span: DUMMY_SP,
arg: Some(v.take()),
}
.into(),
);
*body = BlockStmtOrExpr::BlockStmt(BlockStmt {
span: DUMMY_SP,
stmts,
..Default::default()
});
}
}
}
fn visit_mut_catch_clause(&mut self, f: &mut CatchClause) {
f.visit_mut_children_with(self);
let mut params = Vec::new();
if f.param.is_some() {
params.push(Param {
span: DUMMY_SP,
decorators: Vec::new(),
pat: f.param.take().unwrap(),
});
}
self.visit_mut_fn_like(&mut params, &mut f.body, false);
assert!(
params.is_empty() || params.len() == 1,
"fold_fn_like should return 0 ~ 1 parameter while handling catch clause"
);
let param = if params.is_empty() {
None
} else {
Some(params.pop().unwrap())
};
f.param = param.map(|param| param.pat);
}
fn visit_mut_constructor(&mut self, f: &mut Constructor) {
trace!("visit_mut_constructor(parmas.len() = {})", f.params.len());
f.params.visit_mut_with(self);
if let Some(BlockStmt { stmts, .. }) = &mut f.body {
let old_rep = self.hoister.take();
stmts.visit_mut_children_with(self);
if self.in_subclass {
let (decl, this_id) =
mem::replace(&mut self.hoister, old_rep).to_stmt_in_subclass();
if let Some(stmt) = decl {
if let Some(this_id) = this_id {
init_this(stmts, &this_id)
}
prepend_stmt(stmts, stmt);
}
} else {
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(stmt) = decl {
prepend_stmt(stmts, stmt);
}
}
}
trace!(
"visit_mut_constructor(parmas.len() = {}, after)",
f.params.len()
);
}
fn visit_mut_expr(&mut self, e: &mut Expr) {
match e {
Expr::Arrow(f) => {
f.visit_mut_children_with(self);
let was_expr = f.body.is_expr();
let need_arrow_to_function = f.params.iter().any(|p| match p {
Pat::Rest(..) => true,
Pat::Assign(..) => !self.c.ignore_function_length,
_ => false,
});
let mut local_vars = None;
// this needs to happen before rest parameter transform
if need_arrow_to_function {
if !self.in_prop {
f.visit_mut_children_with(&mut self.hoister)
} else {
let mut hoister = FnEnvHoister::new(self.unresolved_ctxt);
f.visit_mut_children_with(&mut hoister);
local_vars = hoister.to_stmt();
}
}
let mut params = f
.params
.take()
.into_iter()
.map(|pat| Param {
span: DUMMY_SP,
decorators: Default::default(),
pat,
})
.collect();
let mut body = match *f.body.take() {
BlockStmtOrExpr::BlockStmt(block) => block,
BlockStmtOrExpr::Expr(expr) => BlockStmt {
stmts: vec![Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: Some(expr),
})],
..Default::default()
},
};
self.visit_mut_fn_like(&mut params, &mut body, false);
if need_arrow_to_function {
let func: Expr = Function {
params,
decorators: Default::default(),
span: f.span,
body: Some(body),
is_generator: f.is_generator,
is_async: f.is_async,
..Default::default()
}
.into();
*e = match (self.in_prop, local_vars) {
(true, Some(var_decl)) => ArrowExpr {
span: f.span,
params: Vec::new(),
is_async: false,
is_generator: false,
body: Box::new(BlockStmtOrExpr::BlockStmt(BlockStmt {
span: f.span,
stmts: vec![
var_decl,
Stmt::Return(ReturnStmt {
span: f.span,
arg: Some(Box::new(func)),
}),
],
..Default::default()
})),
..Default::default()
}
.as_iife()
.into(),
_ => func,
};
return;
}
let body = if was_expr
&& body.stmts.len() == 1
&& matches!(
body.stmts[0],
Stmt::Return(ReturnStmt { arg: Some(..), .. })
) {
match body.stmts.pop().unwrap() {
Stmt::Return(ReturnStmt { arg: Some(arg), .. }) => {
Box::new(BlockStmtOrExpr::Expr(arg))
}
_ => unreachable!(),
}
} else {
Box::new(BlockStmtOrExpr::BlockStmt(body))
};
*e = ArrowExpr {
params: params.into_iter().map(|param| param.pat).collect(),
body,
span: f.span,
is_async: f.is_async,
is_generator: f.is_generator,
type_params: f.type_params.take(),
return_type: f.return_type.take(),
..Default::default()
}
.into();
}
_ => e.visit_mut_children_with(self),
}
}
fn visit_mut_function(&mut self, f: &mut Function) {
if f.body.is_none() {
return;
}
let old_in_subclass = self.in_subclass;
let old_in_prop = self.in_prop;
self.in_subclass = false;
self.in_prop = false;
f.visit_mut_children_with(self);
let mut body = f.body.take().unwrap();
self.visit_mut_fn_like(&mut f.params, &mut body, false);
f.body = Some(body);
self.in_subclass = old_in_subclass;
self.in_prop = old_in_prop;
}
fn visit_mut_getter_prop(&mut self, f: &mut GetterProp) {
if f.body.is_none() {
return;
}
f.visit_mut_children_with(self);
let mut params = Vec::new();
let mut body = f.body.take().unwrap();
self.visit_mut_fn_like(&mut params, &mut body, false);
debug_assert_eq!(params, Vec::new());
f.body = Some(body);
}
fn visit_mut_setter_prop(&mut self, f: &mut SetterProp) {
if f.body.is_none() {
return;
}
f.visit_mut_children_with(self);
let mut params = vec![Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: *f.param.take(),
}];
let mut body = f.body.take().unwrap();
self.visit_mut_fn_like(&mut params, &mut body, true);
debug_assert!(params.len() == 1);
f.param = Box::new(params.pop().unwrap().pat);
f.body = Some(body);
}
fn visit_mut_class(&mut self, c: &mut Class) {
let old_in_subclass = self.in_subclass;
let old_in_prop = self.in_prop;
self.in_subclass = c.super_class.is_some();
self.in_prop = false;
c.visit_mut_children_with(self);
self.in_subclass = old_in_subclass;
self.in_prop = old_in_prop;
}
fn visit_mut_module_items(&mut self, stmts: &mut Vec<ModuleItem>) {
stmts.visit_mut_children_with(self);
let decl = self.hoister.take().to_stmt();
if let Some(stmt) = decl {
prepend_stmt(stmts, stmt.into());
}
}
fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
let old_rep = self.hoister.take();
stmts.visit_mut_children_with(self);
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(stmt) = decl {
prepend_stmt(stmts, stmt);
}
}
}
fn make_arg_nth(n: usize) -> MemberExpr {
Ident::new_no_ctxt("arguments".into(), DUMMY_SP).computed_member(n)
}
fn check_arg_len(n: usize) -> Expr {
BinExpr {
left: Expr::Ident(Ident::new_no_ctxt("arguments".into(), DUMMY_SP))
.make_member(IdentName::new("length".into(), DUMMY_SP))
.into(),
op: op!(">"),
right: n.into(),
span: DUMMY_SP,
}
.into()
}
fn check_arg_len_or_undef(n: usize) -> Expr {
CondExpr {
test: Box::new(check_arg_len(n)),
cons: make_arg_nth(n).into(),
alt: Expr::undefined(DUMMY_SP),
span: DUMMY_SP,
}
.into()
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/regenerator/mod.rs | Rust | use serde::{Deserialize, Serialize};
use swc_atoms::Atom;
use swc_config::merge::Merge;
#[derive(Debug, Default, Clone, Serialize, Deserialize, Merge)]
#[serde(rename_all = "camelCase")]
pub struct Config {
/// Import path used instead of `regenerator-runtime`
#[serde(default)]
pub import_path: Option<Atom>,
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/shorthand_property.rs | Rust | use swc_common::util::take::Take;
use swc_ecma_ast::*;
use swc_ecma_transforms_base::perf::Parallel;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
/// Compile ES2015 shorthand properties to ES5
///
///# Example
///
///## In
///
/// ```js
/// var o = { a, b, c };
/// ```
///
///## Out
///
/// ```js
/// var o = { a: a, b: b, c: c };
/// ```
///
///## In
///
/// ```js
/// var cat = {
/// getName() {
/// return name;
/// }
/// };
/// ```
///
///## Out
///```js
/// var cat = {
/// getName: function () {
/// return name;
/// }
/// };
/// ```
pub fn shorthand() -> impl Pass {
visit_mut_pass(Shorthand)
}
#[derive(Clone, Copy)]
struct Shorthand;
impl Parallel for Shorthand {
fn create(&self) -> Self {
*self
}
fn merge(&mut self, _: Self) {}
}
#[swc_trace]
impl VisitMut for Shorthand {
noop_visit_mut_type!(fail);
fn visit_mut_prop(&mut self, prop: &mut Prop) {
prop.visit_mut_children_with(self);
match prop {
Prop::Shorthand(ident) => {
let value = ident.clone().into();
*prop = Prop::KeyValue(KeyValueProp {
key: if ident.sym == "__proto__" {
PropName::Computed(ComputedPropName {
span: ident.span,
expr: ident.sym.clone().into(),
})
} else {
ident.take().into()
},
value,
});
}
Prop::Method(MethodProp { key, function }) => {
let key = match key.take() {
PropName::Ident(IdentName { span, sym, .. }) if sym == "__proto__" => {
ComputedPropName {
span,
expr: sym.into(),
}
.into()
}
PropName::Str(s @ Str { span, .. }) if s.value == "__proto__" => {
ComputedPropName {
span,
expr: s.into(),
}
.into()
}
key => key,
};
*prop = Prop::KeyValue(KeyValueProp {
key,
value: FnExpr {
ident: None,
function: function.take(),
}
.into(),
})
}
_ => {}
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/spread.rs | Rust | use std::mem;
use serde::Deserialize;
use swc_common::{util::take::Take, Span, Spanned, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{ext::ExprRefExt, helper, perf::Check};
use swc_ecma_transforms_macros::fast_path;
use swc_ecma_utils::{
alias_ident_for, member_expr, prepend_stmt, quote_ident, ExprFactory, StmtLike,
};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith, VisitWith,
};
use swc_trace_macro::swc_trace;
pub fn spread(c: Config) -> impl Pass {
visit_mut_pass(Spread {
c,
vars: Default::default(),
})
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
pub loose: bool,
}
/// es2015 - `SpreadElement`
#[derive(Default)]
struct Spread {
c: Config,
vars: Vec<VarDeclarator>,
}
#[swc_trace]
#[fast_path(SpreadFinder)]
impl VisitMut for Spread {
noop_visit_mut_type!(fail);
fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem>) {
self.visit_mut_stmt_like(n);
}
fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt>) {
self.visit_mut_stmt_like(n);
}
fn visit_mut_expr(&mut self, e: &mut Expr) {
e.visit_mut_children_with(self);
match e {
Expr::Array(ArrayLit { span, elems }) => {
if !elems.iter().any(|e| {
matches!(
e,
Some(ExprOrSpread {
spread: Some(_),
..
})
)
}) {
return;
}
*e = self.concat_args(*span, elems.take().into_iter(), true);
}
// super(...spread) should be removed by es2015::classes pass
Expr::Call(CallExpr {
callee: Callee::Expr(callee),
args,
span,
..
}) => {
let has_spread = args
.iter()
.any(|ExprOrSpread { spread, .. }| spread.is_some());
if !has_spread {
return;
}
let (this, callee_updated) = match &**callee {
Expr::SuperProp(SuperPropExpr {
obj: Super { span, .. },
..
}) => (ThisExpr { span: *span }.into(), None),
Expr::Member(MemberExpr { obj, .. }) if obj.is_this() => (obj.clone(), None),
// Injected variables can be accessed without any side effect
Expr::Member(MemberExpr { obj, .. })
if obj.as_ident().is_some() && obj.as_ident().unwrap().span.is_dummy() =>
{
(obj.as_ident().unwrap().clone().into(), None)
}
Expr::Ident(Ident { span, .. }) => (Expr::undefined(*span), None),
Expr::Member(MemberExpr { span, obj, prop }) => {
let ident = alias_ident_for(obj, "_instance");
self.vars.push(VarDeclarator {
span: DUMMY_SP,
definite: false,
// Initialized by paren expression.
name: ident.clone().into(),
// Initialized by paren expression.
init: None,
});
let this = ident.clone().into();
let callee: Expr = AssignExpr {
span: DUMMY_SP,
left: ident.into(),
op: op!("="),
right: obj.clone(),
}
.into();
(
this,
Some(
MemberExpr {
span: *span,
obj: callee.into(),
prop: prop.clone(),
}
.into(),
),
)
}
// https://github.com/swc-project/swc/issues/400
// _ => (undefined(callee.span()), callee),
_ => (
ThisExpr {
span: callee.span(),
}
.into(),
None,
),
};
let args_array = if args.iter().all(|e| {
matches!(e, ExprOrSpread { spread: None, .. })
|| matches!(e, ExprOrSpread { expr, .. } if expr.is_array())
}) {
ArrayLit {
span: *span,
elems: expand_literal_args(args.take().into_iter().map(Some)),
}
.into()
} else {
self.concat_args(*span, args.take().into_iter().map(Some), false)
};
let apply = MemberExpr {
span: DUMMY_SP,
obj: callee_updated.unwrap_or_else(|| callee.take()),
prop: quote_ident!("apply").into(),
};
*e = CallExpr {
span: *span,
callee: apply.as_callee(),
args: vec![this.as_arg(), args_array.as_arg()],
..Default::default()
}
.into()
}
Expr::New(NewExpr {
callee,
args: Some(args),
span,
..
}) => {
let has_spread = args
.iter()
.any(|ExprOrSpread { spread, .. }| spread.is_some());
if !has_spread {
return;
}
let args = self.concat_args(*span, args.take().into_iter().map(Some), true);
*e = CallExpr {
span: *span,
callee: helper!(construct),
args: vec![callee.take().as_arg(), args.as_arg()],
..Default::default()
}
.into();
}
_ => {}
};
}
}
#[swc_trace]
impl Spread {
fn visit_mut_stmt_like<T>(&mut self, items: &mut Vec<T>)
where
T: StmtLike,
Vec<T>: VisitMutWith<Self>,
{
let orig = self.vars.take();
items.visit_mut_children_with(self);
if !self.vars.is_empty() {
prepend_stmt(
items,
T::from(
VarDecl {
kind: VarDeclKind::Var,
decls: self.vars.take(),
..Default::default()
}
.into(),
),
);
}
self.vars = orig;
}
}
#[swc_trace]
impl Spread {
fn concat_args(
&self,
span: Span,
args: impl ExactSizeIterator<Item = Option<ExprOrSpread>>,
need_array: bool,
) -> Expr {
//
// []
//
let mut first_arr = None;
let mut tmp_arr = Vec::new();
let mut buf = Vec::new();
let args_len = args.len();
macro_rules! make_arr {
() => {
let elems = mem::take(&mut tmp_arr);
match first_arr {
Some(_) => {
if !elems.is_empty() {
buf.push(ArrayLit { span, elems }.as_arg());
}
}
None => {
first_arr = Some(Expr::Array(ArrayLit { span, elems }));
}
}
};
}
// Shorthand [].concat(arr1, arr2) should be used under loose mode.
// Array.prototype.concat has the lovely feature by which arrays passed
// to it are depth-1 flattened. This effectively implements the loose
// spread. But if any arrays that are not being spread are present, they
// will be incorrectly flattened. The solution is to wrap every
// contiguous slice of non-spread args in an array, which will protect
// array args from being flattened.
if self.c.loose {
let mut arg_list = Vec::new();
let mut current_elems = Vec::new();
for arg in args.flatten() {
let expr = arg.expr;
match arg.spread {
Some(_) => {
if !current_elems.is_empty() {
arg_list.push(
ArrayLit {
span: DUMMY_SP,
elems: current_elems,
}
.as_arg(),
);
current_elems = Vec::new();
}
arg_list.push(expr.as_arg());
}
None => {
current_elems.push(Some(expr.as_arg()));
}
}
}
if !current_elems.is_empty() {
arg_list.push(
ArrayLit {
span: DUMMY_SP,
elems: current_elems,
}
.as_arg(),
);
}
return CallExpr {
span: DUMMY_SP,
callee: ArrayLit {
span: DUMMY_SP,
elems: Vec::new(),
}
.make_member(quote_ident!("concat"))
.as_callee(),
args: arg_list,
..Default::default()
}
.into();
}
for arg in args {
if let Some(arg) = arg {
let ExprOrSpread { expr, spread } = arg;
fn to_consumable_array(expr: Box<Expr>, span: Span) -> CallExpr {
if matches!(*expr, Expr::Lit(Lit::Str(..))) {
CallExpr {
span,
callee: quote_ident!("Array")
.make_member(quote_ident!("from"))
.as_callee(),
args: vec![expr.as_arg()],
..Default::default()
}
} else {
CallExpr {
span,
callee: helper!(to_consumable_array),
args: vec![expr.as_arg()],
..Default::default()
}
}
}
match spread {
// ...b -> toConsumableArray(b)
Some(span) => {
//
make_arr!();
buf.push(match *expr {
Expr::Ident(Ident { ref sym, .. }) if &**sym == "arguments" => {
if args_len == 1 {
if need_array {
return CallExpr {
span,
callee: member_expr!(
Default::default(),
DUMMY_SP,
Array.prototype.slice.call
)
.as_callee(),
args: vec![expr.as_arg()],
..Default::default()
}
.into();
} else {
return *expr;
}
} else {
CallExpr {
span,
callee: member_expr!(
Default::default(),
DUMMY_SP,
Array.prototype.slice.call
)
.as_callee(),
args: vec![expr.as_arg()],
..Default::default()
}
.as_arg()
}
}
_ => {
if args_len == 1 && !need_array {
return if self.c.loose {
*expr
} else {
to_consumable_array(expr, span).into()
};
}
// [].concat(arr) is shorter than _to_consumable_array(arr)
if args_len == 1 {
return if self.c.loose {
CallExpr {
span: DUMMY_SP,
callee: ArrayLit {
span: DUMMY_SP,
elems: Vec::new(),
}
.make_member(quote_ident!("concat"))
.as_callee(),
args: vec![expr.as_arg()],
..Default::default()
}
.into()
} else {
to_consumable_array(expr, span).into()
};
}
to_consumable_array(expr, span).as_arg()
}
});
}
None => tmp_arr.push(Some(expr.as_arg())),
}
} else {
tmp_arr.push(None);
}
}
make_arr!();
if !buf.is_empty()
&& match first_arr {
None => true,
Some(Expr::Array(ref arr)) if arr.elems.is_empty() => true,
_ => false,
}
{
let callee = buf
.remove(0)
.expr
.make_member(IdentName::new("concat".into(), DUMMY_SP))
.as_callee();
return CallExpr {
span,
callee,
args: buf,
..Default::default()
}
.into();
}
CallExpr {
// TODO
span,
callee: first_arr
.take()
.unwrap_or_else(|| {
// No arg
// assert!(args.is_empty());
Expr::Array(ArrayLit {
span,
elems: Vec::new(),
})
})
.make_member(IdentName::new("concat".into(), span))
.as_callee(),
args: buf,
..Default::default()
}
.into()
}
}
#[tracing::instrument(level = "info", skip_all)]
fn expand_literal_args(
args: impl ExactSizeIterator<Item = Option<ExprOrSpread>>,
) -> Vec<Option<ExprOrSpread>> {
fn expand(
buf: &mut Vec<Option<ExprOrSpread>>,
args: impl ExactSizeIterator<Item = Option<ExprOrSpread>>,
) {
for mut arg in args {
if let Some(ExprOrSpread {
spread: Some(spread_span),
expr,
}) = arg
{
match *expr {
Expr::Array(arr) => {
expand(buf, arr.elems.into_iter());
continue;
}
_ => {
arg = Some(ExprOrSpread {
spread: Some(spread_span),
expr,
})
}
}
}
buf.push(arg)
}
}
let mut buf = Vec::with_capacity(args.len() + 4);
expand(&mut buf, args);
buf
}
#[derive(Default)]
struct SpreadFinder {
found: bool,
}
impl Visit for SpreadFinder {
noop_visit_type!(fail);
fn visit_expr_or_spread(&mut self, n: &ExprOrSpread) {
n.visit_children_with(self);
self.found |= n.spread.is_some();
}
}
impl Check for SpreadFinder {
fn should_handle(&self) -> bool {
self.found
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/sticky_regex.rs | Rust | use swc_ecma_ast::*;
use swc_ecma_transforms_base::perf::Parallel;
use swc_ecma_utils::{quote_ident, ExprFactory};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
/// Compile ES2015 sticky regex to an ES5 RegExp constructor
///
///# Example
///## In
///
/// ```js
/// /o+/y;
/// ```
///
///## Out
///
/// ```js
/// new RegExp("o+", "y")
/// ```
pub fn sticky_regex() -> impl Pass {
visit_mut_pass(StickyRegex)
}
struct StickyRegex;
impl Parallel for StickyRegex {
fn merge(&mut self, _: Self) {}
fn create(&self) -> Self {
StickyRegex
}
}
#[swc_trace]
impl VisitMut for StickyRegex {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, e: &mut Expr) {
e.visit_mut_children_with(self);
if let Expr::Lit(Lit::Regex(Regex { exp, flags, span })) = e {
if flags.contains('y') {
*e = NewExpr {
span: *span,
callee: Box::new(quote_ident!(Default::default(), *span, "RegExp").into()),
args: Some(vec![exp.clone().as_arg(), flags.clone().as_arg()]),
..Default::default()
}
.into()
}
}
}
}
#[cfg(test)]
mod tests {
use swc_ecma_transforms_testing::test;
use super::*;
test!(
::swc_ecma_parser::Syntax::default(),
|_| sticky_regex(),
babel_basic,
"var re = /o\"'+/y;"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| sticky_regex(),
babel_ignore_non_sticky,
"var re = /o+/;"
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/template_literal.rs | Rust | use std::{iter, mem};
use serde_derive::Deserialize;
use swc_atoms::Atom;
use swc_common::{util::take::Take, BytePos, Spanned, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{helper, perf::Parallel};
use swc_ecma_utils::{is_literal, prepend_stmts, private_ident, quote_ident, ExprFactory};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
pub fn template_literal(c: Config) -> impl Pass {
visit_mut_pass(TemplateLiteral {
c,
..Default::default()
})
}
#[derive(Default)]
struct TemplateLiteral {
added: Vec<Stmt>,
c: Config,
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
#[serde(default)]
pub ignore_to_primitive: bool,
#[serde(default)]
pub mutable_template: bool,
}
impl Parallel for TemplateLiteral {
fn create(&self) -> Self {
Self::default()
}
fn merge(&mut self, other: Self) {
self.added.extend(other.added);
}
}
#[swc_trace]
impl VisitMut for TemplateLiteral {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, e: &mut Expr) {
e.visit_mut_children_with(self);
match e {
Expr::Tpl(Tpl {
span,
exprs,
quasis,
..
}) => {
assert_eq!(quasis.len(), exprs.len() + 1);
// This makes result of addition string
let mut obj: Box<Expr> = Box::new(
Lit::Str({
let s = quasis[0]
.cooked
.clone()
.unwrap_or_else(|| quasis[0].raw.clone());
Str {
span: quasis[0].span,
value: Atom::from(&*s),
raw: None,
}
})
.into(),
);
let len = quasis.len() + exprs.len();
let mut args = Vec::new();
let mut quasis = quasis.iter_mut();
let mut exprs = exprs.take().into_iter();
for i in 0..len {
if i == 0 {
quasis.next();
continue;
}
let last = i == len - 1;
let expr = if i % 2 == 0 {
// Quasis
match quasis.next() {
Some(TplElement {
span, cooked, raw, ..
}) => {
let s = cooked.clone().unwrap_or_else(|| raw.clone());
Box::new(
Lit::Str(Str {
span: *span,
value: (&*s).into(),
raw: None,
})
.into(),
)
}
_ => unreachable!(),
}
} else {
// Expression
exprs.next().unwrap()
};
let expr_span = expr.span();
// We can optimize if expression is a literal or ident
let is_lit = is_literal(&expr);
if is_lit {
let is_empty = match &*expr {
Expr::Lit(Lit::Str(Str { value, .. })) => value.is_empty(),
_ => false,
};
if !is_empty && args.is_empty() {
if let Expr::Lit(Lit::Str(Str { span, value, raw })) = *obj {
match *expr {
Expr::Lit(Lit::Str(Str {
span: r_span,
value: r_value,
..
})) => {
obj = Lit::Str(Str {
span: span.with_hi(r_span.hi()),
raw: None,
value: format!("{}{}", value, r_value).into(),
})
.into();
continue;
}
_ => {
obj = Lit::Str(Str { span, raw, value }).into();
}
}
}
}
if !is_empty {
args.push(expr);
}
if last && !args.is_empty() {
obj = if self.c.ignore_to_primitive {
let args = mem::take(&mut args);
for arg in args {
obj = BinExpr {
span: span.with_hi(expr_span.hi() + BytePos(1)),
op: op!(bin, "+"),
left: obj,
right: arg,
}
.into()
}
obj
} else {
CallExpr {
span: span.with_hi(expr_span.hi() + BytePos(1)),
callee: MemberExpr {
span: DUMMY_SP,
obj,
prop: MemberProp::Ident(IdentName::new(
"concat".into(),
expr_span,
)),
}
.as_callee(),
args: mem::take(&mut args)
.into_iter()
.map(|expr| expr.as_arg())
.collect(),
..Default::default()
}
.into()
}
}
} else {
if !args.is_empty() {
obj = if self.c.ignore_to_primitive {
let args = mem::take(&mut args);
let len = args.len();
for arg in args {
// for `${asd}a`
if let Expr::Lit(Lit::Str(s)) = obj.as_ref() {
if s.value.len() == 0 && len == 2 {
obj = arg;
continue;
}
}
obj = BinExpr {
span: span.with_hi(expr_span.hi() + BytePos(1)),
op: op!(bin, "+"),
left: obj,
right: arg,
}
.into()
}
obj
} else {
CallExpr {
span: span.with_hi(expr_span.hi() + BytePos(1)),
callee: MemberExpr {
span: DUMMY_SP,
obj,
prop: MemberProp::Ident(IdentName::new(
"concat".into(),
expr_span,
)),
}
.as_callee(),
args: mem::take(&mut args)
.into_iter()
.map(|expr| expr.as_arg())
.collect(),
..Default::default()
}
.into()
};
}
debug_assert!(args.is_empty());
args.push(expr);
}
}
*e = *obj
}
Expr::TaggedTpl(TaggedTpl { tag, tpl, .. }) => {
assert_eq!(tpl.quasis.len(), tpl.exprs.len() + 1);
let fn_ident = private_ident!("_templateObject");
let f = Function {
span: DUMMY_SP,
is_async: false,
is_generator: false,
params: Vec::new(),
body: {
// const data = _tagged_template_literal(["first", "second"]);
let data_decl = VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: quote_ident!("data").into(),
definite: false,
init: Some(Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
callee: if self.c.mutable_template {
helper!(tagged_template_literal_loose)
} else {
helper!(tagged_template_literal)
},
args: {
let has_escape =
tpl.quasis.iter().any(|s| s.raw.contains('\\'));
let raw = if has_escape {
Some(
ArrayLit {
span: DUMMY_SP,
elems: tpl
.quasis
.iter()
.cloned()
.map(|elem| elem.raw.as_arg())
.map(Some)
.collect(),
}
.as_arg(),
)
} else {
None
};
iter::once(
ArrayLit {
span: DUMMY_SP,
elems: tpl
.quasis
.take()
.into_iter()
.map(|elem| match elem.cooked {
Some(cooked) => cooked.as_arg(),
None => Expr::undefined(DUMMY_SP).as_arg(),
})
.map(Some)
.collect(),
}
.as_arg(),
)
.chain(raw)
.collect()
},
..Default::default()
}))),
}],
..Default::default()
};
// _templateObject2 = function () {
// return data;
// };
let assign_expr: Expr = {
AssignExpr {
span: DUMMY_SP,
left: fn_ident.clone().into(),
op: op!("="),
right: Function {
span: DUMMY_SP,
is_async: false,
is_generator: false,
params: Vec::new(),
body: Some(BlockStmt {
span: DUMMY_SP,
stmts: vec![Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: Some(Box::new(quote_ident!("data").into())),
})],
..Default::default()
}),
..Default::default()
}
.into(),
}
.into()
};
Some(BlockStmt {
span: DUMMY_SP,
stmts: vec![
data_decl.into(),
assign_expr.into_stmt(),
Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: Some(Box::new(quote_ident!("data").into())),
}),
],
..Default::default()
})
},
..Default::default()
};
self.added.push(
FnDecl {
declare: false,
ident: fn_ident.clone(),
function: f.into(),
}
.into(),
);
*e = CallExpr {
span: DUMMY_SP,
callee: tag.take().as_callee(),
args: iter::once(
CallExpr {
span: DUMMY_SP,
callee: fn_ident.as_callee(),
args: Vec::new(),
..Default::default()
}
.as_arg(),
)
.chain(tpl.exprs.take().into_iter().map(|e| e.as_arg()))
.collect(),
..Default::default()
}
.into()
}
_ => {}
}
}
fn visit_mut_module(&mut self, m: &mut Module) {
m.visit_mut_children_with(self);
prepend_stmts(&mut m.body, self.added.drain(..).map(ModuleItem::from));
}
fn visit_mut_script(&mut self, m: &mut Script) {
m.visit_mut_children_with(self);
prepend_stmts(&mut m.body, self.added.drain(..));
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/src/typeof_symbol.rs | Rust | use swc_common::{util::take::Take, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{helper, perf::Parallel};
use swc_ecma_utils::{quote_str, ExprFactory};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
pub fn typeof_symbol() -> impl Pass {
visit_mut_pass(TypeOfSymbol)
}
#[derive(Clone, Copy)]
struct TypeOfSymbol;
#[swc_trace]
impl Parallel for TypeOfSymbol {
fn merge(&mut self, _: Self) {}
fn create(&self) -> Self {
TypeOfSymbol
}
}
#[swc_trace]
impl VisitMut for TypeOfSymbol {
noop_visit_mut_type!(fail);
fn visit_mut_bin_expr(&mut self, expr: &mut BinExpr) {
match expr.op {
op!("==") | op!("!=") | op!("===") | op!("!==") => {}
_ => {
expr.visit_mut_children_with(self);
return;
}
}
if let Expr::Unary(UnaryExpr {
op: op!("typeof"), ..
}) = *expr.left
{
if is_non_symbol_literal(&expr.right) {
return;
}
}
if let Expr::Unary(UnaryExpr {
op: op!("typeof"), ..
}) = *expr.right
{
if is_non_symbol_literal(&expr.left) {
return;
}
}
expr.visit_mut_children_with(self)
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Expr::Unary(UnaryExpr {
span,
op: op!("typeof"),
arg,
}) = expr
{
match &**arg {
Expr::Ident(..) => {
let undefined_str: Box<Expr> = quote_str!("undefined").into();
let test = BinExpr {
span: DUMMY_SP,
op: op!("==="),
left: Box::new(
UnaryExpr {
span: DUMMY_SP,
op: op!("typeof"),
arg: arg.clone(),
}
.into(),
),
right: undefined_str.clone(),
}
.into();
let call = CallExpr {
span: *span,
callee: helper!(*span, type_of),
args: vec![arg.take().as_arg()],
..Default::default()
}
.into();
*expr = CondExpr {
span: *span,
test,
cons: undefined_str,
alt: Box::new(call),
}
.into();
}
_ => {
let call = CallExpr {
span: *span,
callee: helper!(*span, type_of),
args: vec![arg.take().as_arg()],
..Default::default()
}
.into();
*expr = call;
}
}
}
}
fn visit_mut_fn_decl(&mut self, f: &mut FnDecl) {
if &f.ident.sym == "_type_of" {
return;
}
f.visit_mut_children_with(self);
}
fn visit_mut_function(&mut self, f: &mut Function) {
if let Some(body) = &f.body {
if let Some(Stmt::Expr(first)) = body.stmts.first() {
if let Expr::Lit(Lit::Str(s)) = &*first.expr {
match &*s.value {
"@swc/helpers - typeof" | "@babel/helpers - typeof" => return,
_ => {}
}
}
}
}
f.visit_mut_children_with(self);
}
}
#[tracing::instrument(level = "info", skip_all)]
fn is_non_symbol_literal(e: &Expr) -> bool {
match e {
Expr::Lit(Lit::Str(Str { value, .. })) => matches!(
&**value,
"undefined" | "boolean" | "number" | "string" | "function"
),
_ => false,
}
}
#[cfg(test)]
mod tests {
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_testing::test;
use super::*;
test!(
Syntax::default(),
|_| typeof_symbol(),
dont_touch_non_symbol_comparison,
"typeof window !== 'undefined'"
);
test!(
Syntax::default(),
|_| typeof_symbol(),
dont_touch_non_symbol_comparison_02,
"'undefined' !== typeof window"
);
test!(
Syntax::default(),
|_| typeof_symbol(),
issue_1843_1,
"
function isUndef(type) {
return type === 'undefined';
}
var isWeb = !isUndef(typeof window) && 'onload' in window;
exports.isWeb = isWeb;
var isNode = !isUndef(typeof process) && !!(process.versions && process.versions.node);
exports.isNode = isNode;
var isWeex = !isUndef(typeof WXEnvironment) && WXEnvironment.platform !== 'Web';
exports.isWeex = isWeex;
"
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/block_scoped_fn.rs/basic.js | JavaScript | {
let name = function name(n) {
return n;
};
}name("Steve");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/block_scoped_fn.rs/basic_2.js | JavaScript | {
let foo = function foo() {
return function bar() {
{
let baz = function baz() {};
}
};
function baz() {}
{
let bar = function bar() {};
{
let bar = function bar() {};
}
}
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/block_scoped_fn.rs/hoisting.js | JavaScript | {
let fn1 = function fn1() {
fn2();
};
let fn2 = function fn2() {};
fn1();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/block_scoped_fn.rs/hoisting_directives.js | JavaScript | function foo() {
'use strict';
function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : {
default: obj
};
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/block_scoped_fn.rs/issue_271.js | JavaScript | function foo(scope) {
scope.startOperation = startOperation;
function startOperation(operation) {
scope.agentOperation = operation;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/block_scoped_fn.rs/issue_288_1.js | JavaScript | function components_Link_extends() {
components_Link_extends = Object.assign || function(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i];
for(var key in source){
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return components_Link_extends.apply(this, arguments);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/block_scoped_fn.rs/issue_288_2.js | JavaScript | function _extends() {
module.exports = _extends = Object.assign || function(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i];
for(var key in source){
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/destructuring.rs/nested_for_of.js | JavaScript | for (const ref of Object.entries(o)) {
let _ref = _sliced_to_array(ref, 2),
k1 = _ref[0],
v1 = _ref[1];
for (const ref of Object.entries(o)) {
let _ref = _sliced_to_array(ref, 2),
k2 = _ref[0],
v2 = _ref[1];
console.log(k1, v1, k2, v2);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/issue_1660_1.js | JavaScript | console.log(/*#__PURE__*/ function() {
"use strict";
function _class() {
_class_call_check(this, _class);
}
_create_class(_class, [
{
key: "run",
value: function run() {}
}
]);
return _class;
}());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/issue_169.js | JavaScript | export var Foo = /*#__PURE__*/ function() {
"use strict";
function Foo() {
_class_call_check(this, Foo);
}
_create_class(Foo, [
{
key: "func",
value: function func(a) {
var b = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Date.now();
return {
a: a
};
}
}
]);
return Foo;
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/issue_189.js | JavaScript | var HomePage = /*#__PURE__*/ function(_React_Component) {
"use strict";
_inherits(HomePage, _React_Component);
function HomePage() {
_class_call_check(this, HomePage);
return _call_super(this, HomePage, arguments);
}
return HomePage;
}(React.Component);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/issue_227.js | JavaScript | export default function fn1() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
fn2.apply(void 0, _to_consumable_array(args));
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/issue_271.js | JavaScript | function foo(scope) {
scope.startOperation = startOperation;
function startOperation(operation) {
scope.agentOperation = operation;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/issue_400_1.js | JavaScript | var A = /*#__PURE__*/ function() {
"use strict";
function A() {
_class_call_check(this, A);
this.a_num = 10;
}
_create_class(A, [
{
key: "print",
value: function print() {
expect(this.a_num).toBe(10);
}
}
]);
return A;
}();
var B = /*#__PURE__*/ function(A) {
"use strict";
_inherits(B, A);
function B(num) {
_class_call_check(this, B);
var _this;
_this = _call_super(this, B);
_this.b_num = num;
return _this;
}
_create_class(B, [
{
key: "print",
value: function print() {
expect(this.b_num).toBe(20);
_get(_get_prototype_of(B.prototype), "print", this).call(this);
}
}
]);
return B;
}(A);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/issue_413.js | JavaScript | export var getBadgeBorderRadius = function(text, color) {
return text && style || {};
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/issue_8871.js | JavaScript | var x = "</" + "script>";
var y = "<\/script>";
var z = "\/\/ \\";
export { x, y, z };
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/lib.rs/should_escape_keyword_in_method.js | JavaScript | export var Foo = /*#__PURE__*/ function() {
"use strict";
function Foo() {
_class_call_check(this, Foo);
}
var _proto = Foo.prototype;
_proto.let = function _let() {};
return Foo;
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/object_super.rs/call.js | JavaScript | var _obj;
let obj = _obj = {
a: function a() {
_get(_get_prototype_of(_obj), "y", this).call(this, 1, 2, 3);
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/object_super.rs/do_not_transform.js | JavaScript | let outer = {
b: function b() {
let inner = {
d: function d() {
super.d() // should not transform
;
}
};
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/object_super.rs/get.js | JavaScript | var _obj;
let obj = _obj = {
a: function a() {
let c = _get(_get_prototype_of(_obj), "x", this);
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/object_super.rs/nest.js | JavaScript | var _obj;
let obj = _obj = {
b: function b() {
var _obj1;
_get(_get_prototype_of(_obj), "bar", this).call(this);
let o = _obj1 = {
d: function d() {
_get(_get_prototype_of(_obj1), "d", this).call(this);
}
};
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/object_super.rs/set.js | JavaScript | var _obj;
let obj = _obj = {
a: function a() {
_set(_get_prototype_of(_obj), "x", 1, this, true);
}
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/sticky_regex.rs/babel_basic.js | JavaScript | var re = new RegExp("o\"'+", "y");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/sticky_regex.rs/babel_ignore_non_sticky.js | JavaScript | var re = /o+/;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/typeof_symbol.rs/dont_touch_non_symbol_comparison.js | JavaScript | typeof window !== 'undefined';
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/typeof_symbol.rs/dont_touch_non_symbol_comparison_02.js | JavaScript | 'undefined' !== typeof window;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2015/tests/__swc_snapshots__/src/typeof_symbol.rs/issue_1843_1.js | JavaScript | function isUndef(type) {
return type === 'undefined';
}
var isWeb = !isUndef(typeof window === "undefined" ? "undefined" : _type_of(window)) && 'onload' in window;
exports.isWeb = isWeb;
var isNode = !isUndef(typeof process === "undefined" ? "undefined" : _type_of(process)) && !!(process.versions && process.versions.node);
exports.isNode = isNode;
var isWeex = !isUndef(typeof WXEnvironment === "undefined" ? "undefined" : _type_of(WXEnvironment)) && WXEnvironment.platform !== 'Web';
exports.isWeex = isWeex;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2016/src/exponentiation.rs | Rust | use swc_common::{util::take::Take, Span, Spanned, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::perf::{ParExplode, Parallel};
use swc_ecma_transforms_macros::parallel;
use swc_ecma_utils::{member_expr, private_ident, ExprFactory};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
/// `@babel/plugin-transform-exponentiation-operator`
///
/// # Example
///
/// ## In
///
/// ```js
/// let x = 10 ** 2;
///
/// x **= 3;
/// ```
///
/// ## Out
///
/// ```js
/// let x = Math.pow(10, 2);
///
/// x = Math.pow(x, 3);
/// ```
pub fn exponentiation() -> impl Pass {
visit_mut_pass(Exponentiation::default())
}
#[derive(Default)]
struct Exponentiation {
vars: Vec<VarDeclarator>,
}
impl Parallel for Exponentiation {
fn create(&self) -> Self {
Self::default()
}
fn merge(&mut self, other: Self) {
self.vars.extend(other.vars);
}
}
#[swc_trace]
impl ParExplode for Exponentiation {
fn after_one_stmt(&mut self, stmts: &mut Vec<Stmt>) {
if !self.vars.is_empty() {
stmts.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: self.vars.take(),
declare: false,
..Default::default()
}
.into(),
);
}
}
fn after_one_module_item(&mut self, stmts: &mut Vec<ModuleItem>) {
if !self.vars.is_empty() {
stmts.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: self.vars.take(),
declare: false,
..Default::default()
}
.into(),
);
}
}
}
#[swc_trace]
#[parallel(explode)]
impl VisitMut for Exponentiation {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, e: &mut Expr) {
e.visit_mut_children_with(self);
match e {
Expr::Assign(AssignExpr {
span,
left,
op: op @ op!("**="),
right,
}) => {
let lhs: Ident = match left {
_ if left.as_ident().is_some() => left.as_ident().unwrap().clone().into(),
// unimplemented
AssignTarget::Simple(ref e) => {
let ref_ident = private_ident!(e.span(), "ref");
self.vars.push(VarDeclarator {
span: DUMMY_SP,
name: ref_ident.clone().into(),
init: Some(e.clone().into()),
definite: false,
});
ref_ident
}
left => {
*e = AssignExpr {
span: *span,
left: left.take(),
op: op!("="),
right: right.take(),
}
.into();
return;
}
};
*op = op!("=");
*right = Box::new(mk_call(*span, Box::new(lhs.into()), right.take()));
}
Expr::Bin(BinExpr {
span,
left,
op: op!("**"),
right,
}) => {
*e = mk_call(*span, left.take(), right.take());
}
_ => {}
}
}
}
#[tracing::instrument(level = "info", skip_all)]
fn mk_call(span: Span, left: Box<Expr>, right: Box<Expr>) -> Expr {
// Math.pow()
CallExpr {
span,
callee: member_expr!(Default::default(), span, Math.pow).as_callee(),
args: vec![left.as_arg(), right.as_arg()],
..Default::default()
}
.into()
}
#[cfg(test)]
mod tests {
use swc_ecma_transforms_testing::{test, test_exec};
use super::*;
test!(
::swc_ecma_parser::Syntax::default(),
|_| exponentiation(),
babel_binary,
"2 ** 2"
);
test_exec!(
ignore,
::swc_ecma_parser::Syntax::default(),
|_| exponentiation(),
babel_comprehensive,
r#"expect(2 ** 3).toBe(8);
expect(3 * 2 ** 3).toBe(24);
var x = 2;
expect(2 ** ++x).toBe(8);
expect(2 ** -1 * 2).toBe(1);
var calls = 0;
var q = {q: 3};
var o = {
get p() {
calls++;
return q;
}
};
o.p.q **= 2;
expect(calls).toBe(1);
expect(o.p.q).toBe(9);
expect(2 ** (3 ** 2)).toBe(512);
expect(2 ** 3 ** 2).toBe(512);"#
);
test_exec!(
// FIXME
ignore,
::swc_ecma_parser::Syntax::default(),
|_| exponentiation(),
babel_memoize_object,
r#"var counters = 0;
Object.defineProperty(global, "reader", {
get: function () {
counters += 1;
return { x: 2 };
},
configurable: true
});
reader.x **= 2;
expect(counters).toBe(1);"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| exponentiation(),
assign,
r#"x **= 3"#,
ok_if_code_eq
);
// test!(::swc_ecma_parser::Syntax::default(),
// |_| exponentiation(),
// babel_4403,
// "var a, b;
// a[`${b++}`] **= 1;",
// "var _ref;
// var a, b;
// _ref = `${b++}`, a[_ref] = Math.pow(a[_ref], 1);"
// );
test!(
::swc_ecma_parser::Syntax::default(),
|_| exponentiation(),
issue_740,
"self.a = 10 ** 2",
ok_if_code_eq
);
// https://github.com/swc-project/swc/pull/741/files
// bu JakeChampion
test!(
::swc_ecma_parser::Syntax::default(),
|_| exponentiation(),
babel_binary_member_assignment_expression,
"var x = {}; x.a = 2 ** 2"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| exponentiation(),
assign_to_object_property,
r#"var self = {}; self.x **= 3"#,
ok_if_code_eq
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2016/src/lib.rs | Rust | #![allow(clippy::boxed_local)]
#![allow(clippy::vec_box)]
use swc_ecma_ast::Pass;
pub use self::exponentiation::exponentiation;
mod exponentiation;
pub fn es2016() -> impl Pass {
exponentiation()
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2016/tests/__swc_snapshots__/src/exponentiation.rs/assign.js | JavaScript | x = Math.pow(x, 3);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2016/tests/__swc_snapshots__/src/exponentiation.rs/assign_to_object_property.js | JavaScript | var self = {};
var ref = self.x;
self.x = Math.pow(ref, 3);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2016/tests/__swc_snapshots__/src/exponentiation.rs/babel_binary.js | JavaScript | Math.pow(2, 2);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2016/tests/__swc_snapshots__/src/exponentiation.rs/babel_binary_member_assignment_expression.js | JavaScript | var x = {};
x.a = Math.pow(2, 2);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2016/tests/__swc_snapshots__/src/exponentiation.rs/issue_740.js | JavaScript | self.a = Math.pow(10, 2);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2017/src/async_to_generator.rs | Rust | use std::{iter, mem};
use serde::Deserialize;
use swc_common::{source_map::PURE_SP, util::take::Take, Mark, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{helper, helper_expr, perf::Check};
use swc_ecma_transforms_macros::fast_path;
use swc_ecma_utils::{
contains_this_expr, find_pat_ids,
function::{init_this, FnEnvHoister, FnWrapperResult, FunctionWrapper},
prepend_stmt, private_ident, quote_ident, ExprFactory, Remapper, StmtLike,
};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, visit_mut_pass, Visit, VisitMut, VisitMutWith, VisitWith,
};
use swc_trace_macro::swc_trace;
/// `@babel/plugin-transform-async-to-generator`
///
/// ## In
///
/// ```js
/// async function foo() {
/// await bar();
/// }
/// ```
///
/// ## Out
///
/// ```js
/// var _async_to_generator = function (fn) {
/// ...
/// };
/// var foo = _async_to_generator(function* () {
/// yield bar();
/// });
/// ```
pub fn async_to_generator(c: Config, unresolved_mark: Mark) -> impl Pass {
visit_mut_pass(AsyncToGenerator {
c,
in_subclass: false,
unresolved_ctxt: SyntaxContext::empty().apply_mark(unresolved_mark),
})
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
#[serde(default)]
pub ignore_function_name: bool,
#[serde(default)]
pub ignore_function_length: bool,
}
#[derive(Default, Clone)]
struct AsyncToGenerator {
c: Config,
in_subclass: bool,
unresolved_ctxt: SyntaxContext,
}
struct Actual {
c: Config,
in_subclass: bool,
hoister: FnEnvHoister,
unresolved_ctxt: SyntaxContext,
extra_stmts: Vec<Stmt>,
}
#[swc_trace]
#[fast_path(ShouldWork)]
impl VisitMut for AsyncToGenerator {
noop_visit_mut_type!(fail);
fn visit_mut_class(&mut self, c: &mut Class) {
if c.super_class.is_some() {
self.in_subclass = true;
}
c.visit_mut_children_with(self);
self.in_subclass = false;
}
fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem>) {
self.visit_mut_stmt_like(n);
}
fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt>) {
self.visit_mut_stmt_like(n);
}
}
#[swc_trace]
impl AsyncToGenerator {
fn visit_mut_stmt_like<T>(&mut self, stmts: &mut Vec<T>)
where
T: StmtLike + VisitMutWith<Actual>,
Vec<T>: VisitMutWith<Self>,
{
let mut stmts_updated = Vec::with_capacity(stmts.len());
for mut stmt in stmts.drain(..) {
let hoister = FnEnvHoister::new(self.unresolved_ctxt);
let mut actual = Actual {
c: self.c,
in_subclass: self.in_subclass,
hoister,
unresolved_ctxt: self.unresolved_ctxt,
extra_stmts: Vec::new(),
};
stmt.visit_mut_with(&mut actual);
stmts_updated.extend(actual.hoister.to_stmt().into_iter().map(T::from));
stmts_updated.push(stmt);
stmts_updated.extend(actual.extra_stmts.into_iter().map(T::from));
}
*stmts = stmts_updated;
stmts.visit_mut_children_with(self);
}
}
#[swc_trace]
#[fast_path(ShouldWork)]
impl VisitMut for Actual {
noop_visit_mut_type!(fail);
fn visit_mut_class(&mut self, c: &mut Class) {
let old = self.in_subclass;
if c.super_class.is_some() {
self.in_subclass = true;
}
c.visit_mut_children_with(self);
self.in_subclass = old;
}
fn visit_mut_constructor(&mut self, c: &mut Constructor) {
c.params.visit_mut_children_with(self);
if let Some(BlockStmt { span: _, stmts, .. }) = &mut c.body {
let old_rep = self.hoister.take();
stmts.visit_mut_children_with(self);
if self.in_subclass {
let (decl, this_id) =
mem::replace(&mut self.hoister, old_rep).to_stmt_in_subclass();
if let Some(this_id) = this_id {
init_this(stmts, &this_id)
}
if let Some(decl) = decl {
prepend_stmt(stmts, decl)
}
} else {
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(decl) = decl {
prepend_stmt(stmts, decl)
}
}
}
}
fn visit_mut_class_method(&mut self, m: &mut ClassMethod) {
if m.function.body.is_none() {
return;
}
m.visit_mut_children_with(self);
if m.kind != MethodKind::Method || !m.function.is_async {
return;
}
let params = m.function.params.clone();
let mut visitor = FnEnvHoister::new(self.unresolved_ctxt);
m.function.params.clear();
m.function.body.visit_mut_with(&mut visitor);
let expr = make_fn_ref(FnExpr {
ident: None,
function: m.function.take(),
});
m.function = Function {
span: m.span,
is_async: false,
is_generator: false,
params,
body: Some(BlockStmt {
stmts: visitor
.to_stmt()
.into_iter()
.chain(iter::once(
ReturnStmt {
span: DUMMY_SP,
arg: Some(
CallExpr {
span: DUMMY_SP,
callee: expr.as_callee(),
args: Vec::new(),
..Default::default()
}
.into(),
),
}
.into(),
))
.collect(),
..Default::default()
}),
..Default::default()
}
.into();
}
fn visit_mut_call_expr(&mut self, expr: &mut CallExpr) {
if let Callee::Expr(e) = &mut expr.callee {
let mut e = &mut **e;
while let Expr::Paren(ParenExpr { expr, .. }) = e {
e = &mut **expr;
}
self.visit_mut_expr_with_binding(e, None, true);
}
expr.args.visit_mut_with(self)
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
self.visit_mut_expr_with_binding(expr, None, false);
}
fn visit_mut_function(&mut self, f: &mut Function) {
let old_rep = self.hoister.take();
f.visit_mut_children_with(self);
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let (Some(body), Some(decl)) = (&mut f.body, decl) {
prepend_stmt(&mut body.stmts, decl);
}
}
fn visit_mut_getter_prop(&mut self, f: &mut GetterProp) {
f.key.visit_mut_with(self);
if let Some(body) = &mut f.body {
let old_rep = self.hoister.take();
body.visit_mut_with(self);
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(stmt) = decl {
prepend_stmt(&mut body.stmts, stmt);
}
}
}
fn visit_mut_setter_prop(&mut self, f: &mut SetterProp) {
f.key.visit_mut_with(self);
f.param.visit_mut_with(self);
if let Some(body) = &mut f.body {
let old_rep = self.hoister.take();
body.visit_mut_with(self);
let decl = mem::replace(&mut self.hoister, old_rep).to_stmt();
if let Some(stmt) = decl {
prepend_stmt(&mut body.stmts, stmt);
}
}
}
fn visit_mut_fn_decl(&mut self, f: &mut FnDecl) {
f.visit_mut_children_with(self);
if !f.function.is_async {
return;
}
let mut wrapper = FunctionWrapper::from(f.take());
wrapper.ignore_function_name = self.c.ignore_function_name;
wrapper.ignore_function_length = self.c.ignore_function_length;
let fn_expr = wrapper.function.fn_expr().unwrap();
wrapper.function = make_fn_ref(fn_expr);
let FnWrapperResult { name_fn, ref_fn } = wrapper.into();
*f = name_fn;
self.extra_stmts.push(ref_fn.into());
}
fn visit_mut_module_item(&mut self, item: &mut ModuleItem) {
match item {
// if fn is ExportDefaultDecl, fn is not FnDecl but FnExpr
ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(export_default)) => {
if let DefaultDecl::Fn(expr) = &mut export_default.decl {
if expr.function.is_async {
let mut wrapper = FunctionWrapper::from(expr.take());
wrapper.ignore_function_name = self.c.ignore_function_name;
wrapper.ignore_function_length = self.c.ignore_function_length;
let fn_expr = wrapper.function.fn_expr().unwrap();
wrapper.function = make_fn_ref(fn_expr);
let FnWrapperResult { name_fn, ref_fn } = wrapper.into();
*item = ExportDefaultDecl {
span: export_default.span,
decl: name_fn.into(),
}
.into();
self.extra_stmts.push(ref_fn.into());
};
} else {
export_default.visit_mut_children_with(self);
}
}
_ => item.visit_mut_children_with(self),
};
}
fn visit_mut_method_prop(&mut self, prop: &mut MethodProp) {
prop.visit_mut_children_with(self);
if !prop.function.is_async {
return;
}
let is_this_used = contains_this_expr(&prop.function.body);
let original_fn_params = prop.function.params.take();
let prop_method_span = prop.function.span;
let prop_method_body_span = if let Some(body) = &prop.function.body {
body.span
} else {
DUMMY_SP
};
prop.function.span = prop_method_body_span;
let fn_ref = make_fn_ref(
Function {
params: Vec::new(),
..*prop.function.take()
}
.into(),
);
let fn_ref = if is_this_used {
fn_ref.apply(DUMMY_SP, ThisExpr { span: DUMMY_SP }.into(), Vec::new())
} else {
CallExpr {
span: DUMMY_SP,
callee: fn_ref.as_callee(),
args: Vec::new(),
..Default::default()
}
.into()
};
prop.function = Function {
params: original_fn_params,
span: prop_method_span,
is_async: false,
is_generator: false,
body: Some(BlockStmt {
span: DUMMY_SP,
stmts: vec![Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: Some(Box::new(fn_ref)),
})],
..Default::default()
}),
..Default::default()
}
.into()
}
fn visit_mut_stmts(&mut self, _n: &mut Vec<Stmt>) {}
fn visit_mut_var_declarator(&mut self, var: &mut VarDeclarator) {
if let VarDeclarator {
name: Pat::Ident(id),
init: Some(init),
..
} = var
{
match init.as_ref() {
Expr::Fn(FnExpr {
ident: None,
ref function,
}) if function.is_async || function.is_generator => {
self.visit_mut_expr_with_binding(init, Some(Ident::from(&*id)), false);
return;
}
Expr::Arrow(arrow_expr) if arrow_expr.is_async || arrow_expr.is_generator => {
self.visit_mut_expr_with_binding(init, Some(Ident::from(&*id)), false);
return;
}
_ => {}
}
}
var.visit_mut_children_with(self);
}
}
#[swc_trace]
impl Actual {
fn visit_mut_expr_with_binding(
&mut self,
expr: &mut Expr,
binding_ident: Option<Ident>,
in_iife: bool,
) {
expr.visit_mut_children_with(self);
match expr {
Expr::Arrow(arrow_expr @ ArrowExpr { is_async: true, .. }) => {
arrow_expr.visit_mut_with(&mut self.hoister);
let mut wrapper = FunctionWrapper::from(arrow_expr.take());
wrapper.ignore_function_name = self.c.ignore_function_name;
wrapper.ignore_function_length = self.c.ignore_function_length;
wrapper.binding_ident = binding_ident;
let fn_expr = wrapper.function.expect_fn_expr();
wrapper.function = make_fn_ref(fn_expr);
*expr = wrapper.into();
if !in_iife {
expr.set_span(PURE_SP);
}
}
Expr::Fn(fn_expr) if fn_expr.function.is_async => {
let mut wrapper = FunctionWrapper::from(fn_expr.take());
wrapper.ignore_function_name = self.c.ignore_function_name;
wrapper.ignore_function_length = self.c.ignore_function_length;
wrapper.binding_ident = binding_ident;
let fn_expr = wrapper.function.expect_fn_expr();
wrapper.function = make_fn_ref(fn_expr);
*expr = wrapper.into();
if !in_iife {
expr.set_span(PURE_SP);
}
}
_ => {}
}
}
}
/// Creates
///
/// `_async_to_generator(function*() {})` from `async function() {}`;
#[tracing::instrument(level = "info", skip_all)]
fn make_fn_ref(mut expr: FnExpr) -> Expr {
{
let param_ids: Vec<Id> = find_pat_ids(&expr.function.params);
let mapping = param_ids
.into_iter()
.map(|id| (id, SyntaxContext::empty().apply_mark(Mark::new())))
.collect();
expr.function.visit_mut_with(&mut Remapper::new(&mapping));
}
expr.function.body.visit_mut_with(&mut AsyncFnBodyHandler {
is_async_generator: expr.function.is_generator,
});
assert!(expr.function.is_async);
expr.function.is_async = false;
let helper = if expr.function.is_generator {
helper!(wrap_async_generator)
} else {
helper!(async_to_generator)
};
expr.function.is_generator = true;
let span = expr.span();
CallExpr {
span,
callee: helper,
args: vec![expr.as_arg()],
..Default::default()
}
.into()
}
struct AsyncFnBodyHandler {
is_async_generator: bool,
}
macro_rules! noop {
($name:ident, $T:path) => {
/// Don't recurse into function.
fn $name(&mut self, _f: &mut $T) {}
};
}
#[swc_trace]
impl VisitMut for AsyncFnBodyHandler {
noop_visit_mut_type!(fail);
noop!(visit_mut_fn_expr, FnExpr);
noop!(visit_mut_constructor, Constructor);
noop!(visit_mut_arrow_expr, ArrowExpr);
noop!(visit_mut_fn_decl, FnDecl);
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
match expr {
Expr::Yield(YieldExpr {
span,
arg: Some(arg),
delegate: true,
}) => {
let callee = helper!(async_generator_delegate);
let arg = CallExpr {
span: *span,
callee,
args: vec![
CallExpr {
span: DUMMY_SP,
callee: helper!(async_iterator),
args: vec![arg.take().as_arg()],
..Default::default()
}
.as_arg(),
helper_expr!(await_async_generator).as_arg(),
],
..Default::default()
}
.into();
*expr = YieldExpr {
span: *span,
delegate: true,
arg: Some(arg),
}
.into()
}
Expr::Await(AwaitExpr { span, arg }) => {
if self.is_async_generator {
let callee = helper!(await_async_generator);
let arg = CallExpr {
span: *span,
callee,
args: vec![arg.take().as_arg()],
..Default::default()
}
.into();
*expr = YieldExpr {
span: *span,
delegate: false,
arg: Some(arg),
}
.into()
} else {
*expr = YieldExpr {
span: *span,
delegate: false,
arg: Some(arg.take()),
}
.into()
}
}
_ => {}
}
}
fn visit_mut_stmt(&mut self, s: &mut Stmt) {
s.visit_mut_children_with(self);
handle_await_for(s, self.is_async_generator);
}
}
#[derive(Default)]
struct ShouldWork {
found: bool,
}
#[swc_trace]
impl Visit for ShouldWork {
noop_visit_type!(fail);
fn visit_function(&mut self, f: &Function) {
if f.is_async {
self.found = true;
return;
}
f.visit_children_with(self);
}
fn visit_arrow_expr(&mut self, f: &ArrowExpr) {
if f.is_async {
self.found = true;
return;
}
f.visit_children_with(self);
}
}
impl Check for ShouldWork {
fn should_handle(&self) -> bool {
self.found
}
}
#[tracing::instrument(level = "info", skip_all)]
fn handle_await_for(stmt: &mut Stmt, is_async_generator: bool) {
let s = match stmt {
Stmt::ForOf(s @ ForOfStmt { is_await: true, .. }) => s.take(),
_ => return,
};
let value = private_ident!("_value");
let iterator = private_ident!("_iterator");
let iterator_error = private_ident!("_iteratorError");
let step = private_ident!("_step");
let did_iteration_error = private_ident!("_didIteratorError");
let iterator_abrupt_completion = private_ident!("_iteratorAbruptCompletion");
let err_param = private_ident!("err");
let try_body = {
let body_span = s.body.span();
let orig_body = match *s.body {
Stmt::Block(s) => s.stmts,
_ => vec![*s.body],
};
let mut for_loop_body = Vec::new();
{
// let value = _step.value;
let value_var = VarDeclarator {
span: DUMMY_SP,
name: value.clone().into(),
init: Some(step.clone().make_member(quote_ident!("value")).into()),
definite: false,
};
for_loop_body.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Let,
declare: false,
decls: vec![value_var],
..Default::default()
}
.into(),
);
}
match s.left {
ForHead::VarDecl(v) => {
let var = v.decls.into_iter().next().unwrap();
let var_decl = VarDeclarator {
span: DUMMY_SP,
name: var.name,
init: Some(value.into()),
definite: false,
};
for_loop_body.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Const,
declare: false,
decls: vec![var_decl],
..Default::default()
}
.into(),
);
}
ForHead::Pat(p) => {
for_loop_body.push(
ExprStmt {
span: DUMMY_SP,
expr: AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: p.try_into().unwrap(),
right: Box::new(value.into()),
}
.into(),
}
.into(),
);
}
ForHead::UsingDecl(..) => {
unreachable!("using declaration must be removed by previous pass")
}
}
for_loop_body.extend(orig_body);
let for_loop_body = BlockStmt {
span: body_span,
stmts: for_loop_body,
..Default::default()
};
let mut init_var_decls = Vec::new();
// _iterator = _async_iterator(lol())
init_var_decls.push(VarDeclarator {
span: DUMMY_SP,
name: iterator.clone().into(),
init: {
let callee = helper!(async_iterator);
Some(
CallExpr {
span: DUMMY_SP,
callee,
args: vec![s.right.as_arg()],
..Default::default()
}
.into(),
)
},
definite: false,
});
init_var_decls.push(VarDeclarator {
span: DUMMY_SP,
name: step.clone().into(),
init: None,
definite: false,
});
let for_stmt = ForStmt {
span: s.span,
// var _iterator = _async_iterator(lol()), _step;
init: Some(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: false,
decls: init_var_decls,
..Default::default()
}
.into(),
),
// _iteratorAbruptCompletion = !(_step = yield _iterator.next()).done
test: {
let iter_next = iterator.clone().make_member(quote_ident!("next"));
let iter_next = CallExpr {
span: DUMMY_SP,
callee: iter_next.as_callee(),
args: Default::default(),
..Default::default()
};
let yield_arg = if is_async_generator {
CallExpr {
span: DUMMY_SP,
callee: helper!(await_async_generator),
args: vec![iter_next.as_arg()],
..Default::default()
}
.into()
} else {
iter_next.into()
};
let assign_to_step: Expr = AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: step.into(),
right: YieldExpr {
span: DUMMY_SP,
arg: Some(yield_arg),
delegate: false,
}
.into(),
}
.into();
let right = UnaryExpr {
span: DUMMY_SP,
op: op!("!"),
arg: assign_to_step.make_member(quote_ident!("done")).into(),
}
.into();
let left = iterator_abrupt_completion.clone().into();
Some(
AssignExpr {
span: DUMMY_SP,
op: op!("="),
left,
right,
}
.into(),
)
},
// _iteratorNormalCompletion = true
update: Some(
AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: iterator_abrupt_completion.clone().into(),
right: false.into(),
}
.into(),
),
body: Box::new(Stmt::Block(for_loop_body)),
}
.into();
BlockStmt {
span: body_span,
stmts: vec![for_stmt],
..Default::default()
}
};
let catch_clause = {
// _didIteratorError = true;
let mark_as_errorred = ExprStmt {
span: DUMMY_SP,
expr: AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: did_iteration_error.clone().into(),
right: true.into(),
}
.into(),
}
.into();
// _iteratorError = err;
let store_error = ExprStmt {
span: DUMMY_SP,
expr: AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: iterator_error.clone().into(),
right: Box::new(err_param.clone().into()),
}
.into(),
}
.into();
CatchClause {
span: DUMMY_SP,
param: Some(err_param.into()),
body: BlockStmt {
stmts: vec![mark_as_errorred, store_error],
..Default::default()
},
}
};
let finally_block = {
let throw_iterator_error = ThrowStmt {
span: DUMMY_SP,
arg: iterator_error.clone().into(),
}
.into();
let throw_iterator_error = IfStmt {
span: DUMMY_SP,
test: did_iteration_error.clone().into(),
cons: Box::new(Stmt::Block(BlockStmt {
span: DUMMY_SP,
stmts: vec![throw_iterator_error],
..Default::default()
})),
alt: None,
}
.into();
let iterator_return: Expr = CallExpr {
span: DUMMY_SP,
callee: iterator
.clone()
.make_member(quote_ident!("return"))
.as_callee(),
args: Vec::new(),
..Default::default()
}
.into();
// yield _iterator.return();
// or
// yield _awaitAsyncGenerator(_iterator.return());
let yield_stmt = ExprStmt {
span: DUMMY_SP,
expr: YieldExpr {
span: DUMMY_SP,
delegate: false,
arg: Some(if is_async_generator {
CallExpr {
span: DUMMY_SP,
callee: helper!(await_async_generator),
args: vec![iterator_return.as_arg()],
..Default::default()
}
.into()
} else {
iterator_return.into()
}),
}
.into(),
}
.into();
let conditional_yield = IfStmt {
span: DUMMY_SP,
// _iteratorAbruptCompletion && _iterator.return != null
test: BinExpr {
span: DUMMY_SP,
op: op!("&&"),
// _iteratorAbruptCompletion
left: Box::new(iterator_abrupt_completion.clone().into()),
// _iterator.return != null
right: Box::new(
BinExpr {
span: DUMMY_SP,
op: op!("!="),
left: iterator.make_member(quote_ident!("return")).into(),
right: Null { span: DUMMY_SP }.into(),
}
.into(),
),
}
.into(),
cons: Box::new(Stmt::Block(BlockStmt {
stmts: vec![yield_stmt],
..Default::default()
})),
alt: None,
}
.into();
let body = BlockStmt {
stmts: vec![conditional_yield],
..Default::default()
};
let inner_try = TryStmt {
span: DUMMY_SP,
block: body,
handler: None,
finalizer: Some(BlockStmt {
stmts: vec![throw_iterator_error],
..Default::default()
}),
}
.into();
BlockStmt {
stmts: vec![inner_try],
..Default::default()
}
};
let try_stmt = TryStmt {
span: s.span,
block: try_body,
handler: Some(catch_clause),
finalizer: Some(finally_block),
};
let stmts = vec![
VarDecl {
kind: VarDeclKind::Var,
decls: vec![
// var _iteratorAbruptCompletion = false;
VarDeclarator {
span: DUMMY_SP,
name: iterator_abrupt_completion.into(),
init: Some(false.into()),
definite: false,
},
// var _didIteratorError = false;
VarDeclarator {
span: DUMMY_SP,
name: did_iteration_error.into(),
init: Some(false.into()),
definite: false,
},
// var _iteratorError;
VarDeclarator {
span: DUMMY_SP,
name: iterator_error.into(),
init: None,
definite: false,
},
],
..Default::default()
}
.into(),
try_stmt.into(),
];
*stmt = BlockStmt {
span: s.span,
stmts,
..Default::default()
}
.into()
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2017/src/lib.rs | Rust | use serde::Deserialize;
use swc_common::Mark;
use swc_ecma_ast::Pass;
pub use self::async_to_generator::async_to_generator;
pub mod async_to_generator;
pub fn es2017(c: Config, unresolved_mark: Mark) -> impl Pass {
async_to_generator(c.async_to_generator, unresolved_mark)
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
pub async_to_generator: async_to_generator::Config,
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2018/src/lib.rs | Rust | #![allow(clippy::vec_box)]
#![allow(clippy::boxed_local)]
use serde::Deserialize;
use swc_ecma_ast::Pass;
use swc_ecma_compat_common::regexp::{self, regexp};
pub use self::object_rest_spread::object_rest_spread;
mod object_rest;
pub mod object_rest_spread;
mod object_spread;
pub fn es2018(c: Config) -> impl Pass {
(
regexp(regexp::Config {
dot_all_regex: true,
has_indices: false,
lookbehind_assertion: true,
named_capturing_groups_regex: true,
sticky_regex: false,
unicode_property_regex: true,
unicode_regex: false,
unicode_sets_regex: false,
}),
object_rest_spread(c.object_rest_spread),
)
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
pub object_rest_spread: object_rest_spread::Config,
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2018/src/object_rest.rs | Rust | use std::{
iter,
mem::{self, replace},
};
use swc_common::{util::take::Take, Mark, Spanned, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_compat_common::impl_visit_mut_fn;
use swc_ecma_transforms_base::{helper, helper_expr, perf::Check};
use swc_ecma_transforms_macros::fast_path;
use swc_ecma_utils::{
alias_ident_for, alias_if_required, find_pat_ids, is_literal, private_ident, quote_ident,
var::VarCollector, ExprFactory, StmtLike,
};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, Visit, VisitMut, VisitMutWith, VisitWith,
};
use swc_trace_macro::swc_trace;
use super::object_rest_spread::Config;
#[derive(Default)]
pub(super) struct ObjectRest {
/// Injected before the original statement.
pub vars: Vec<VarDeclarator>,
/// Variables which should be declared using `var`
pub mutable_vars: Vec<VarDeclarator>,
/// Assignment expressions.
pub exprs: Vec<Box<Expr>>,
pub config: Config,
}
macro_rules! impl_for_for_stmt {
($name:ident, $T:tt) => {
fn $name(&mut self, for_stmt: &mut $T) {
if !contains_rest(for_stmt) {
return;
}
let mut stmt = None;
let left = match &mut for_stmt.left {
ForHead::VarDecl(var_decl) => {
let ref_ident = private_ident!("_ref");
// Unpack variables
let mut decls = var_decl
.decls
.take()
.into_iter()
.map(|decl| VarDeclarator {
name: decl.name,
init: Some(Box::new(Expr::Ident(ref_ident.clone()))),
..decl
})
.collect::<Vec<_>>();
// **prepend** decls to self.vars
decls.append(&mut self.vars.take());
stmt = Some(Stmt::Decl(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Let,
decls,
..Default::default()
}
.into(),
));
VarDecl {
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: ref_ident.into(),
init: None,
definite: false,
}],
..*var_decl.take()
}
.into()
}
ForHead::Pat(pat) => {
let var_ident = private_ident!("_ref");
let index = self.vars.len();
let pat = pat.take();
// initialize (or destructure)
match &*pat {
Pat::Object(ObjectPat { ref props, .. }) if props.is_empty() => {}
Pat::Object(ObjectPat { .. }) => {
stmt = Some(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(
AssignExpr {
span: DUMMY_SP,
op: op!("="),
left: pat.try_into().unwrap(),
right: Box::new(Expr::Ident(var_ident.clone())),
}
.into(),
),
}));
}
_ => {
// insert at index to create
// `var { a } = _ref, b = _object_without_properties(_ref, ['a']);`
// instead of
// var b = _object_without_properties(_ref, ['a']), { a } = _ref;
// println!("Var(0): folded pat = var_ident",);
self.vars.insert(
index,
VarDeclarator {
span: DUMMY_SP,
name: *pat,
init: Some(Box::new(Expr::Ident(var_ident.clone()))),
definite: false,
},
);
}
}
// `var _ref` in `for (var _ref in foo)`
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: var_ident.into(),
init: None,
definite: false,
}],
..Default::default()
}
.into()
}
ForHead::UsingDecl(..) => {
unreachable!("using declaration must be removed by previous pass")
}
};
for_stmt.left = left;
for_stmt.body = Box::new(Stmt::Block(match &mut *for_stmt.body {
Stmt::Block(BlockStmt { span, stmts, ctxt }) => BlockStmt {
span: *span,
stmts: stmt.into_iter().chain(stmts.take()).collect(),
ctxt: *ctxt,
},
body => BlockStmt {
span: DUMMY_SP,
stmts: stmt.into_iter().chain(iter::once(body.take())).collect(),
..Default::default()
},
}));
for_stmt.body.visit_mut_with(self);
}
};
}
#[derive(Default)]
struct RestVisitor {
found: bool,
}
#[swc_trace]
impl Visit for RestVisitor {
noop_visit_type!(fail);
fn visit_object_pat_prop(&mut self, prop: &ObjectPatProp) {
match *prop {
ObjectPatProp::Rest(..) => self.found = true,
_ => prop.visit_children_with(self),
}
}
}
impl Check for RestVisitor {
fn should_handle(&self) -> bool {
self.found
}
}
fn contains_rest<N>(node: &N) -> bool
where
N: VisitWith<RestVisitor>,
{
let mut v = RestVisitor { found: false };
node.visit_with(&mut v);
v.found
}
#[swc_trace]
#[fast_path(RestVisitor)]
impl VisitMut for ObjectRest {
noop_visit_mut_type!(fail);
impl_for_for_stmt!(visit_mut_for_in_stmt, ForInStmt);
impl_for_for_stmt!(visit_mut_for_of_stmt, ForOfStmt);
impl_visit_mut_fn!();
/// Handles assign expression
fn visit_mut_expr(&mut self, expr: &mut Expr) {
// fast path
if !contains_rest(expr) {
return;
}
expr.visit_mut_children_with(self);
if let Expr::Assign(AssignExpr {
span,
left: AssignTarget::Pat(pat),
op: op!("="),
right,
}) = expr
{
let mut var_ident = alias_ident_for(right, "_tmp");
var_ident.ctxt = var_ident.ctxt.apply_mark(Mark::new());
// println!("Var: var_ident = None");
self.mutable_vars.push(VarDeclarator {
span: DUMMY_SP,
name: var_ident.clone().into(),
init: None,
definite: false,
});
// println!("Expr: var_ident = right");
self.exprs.push(
AssignExpr {
span: DUMMY_SP,
left: var_ident.clone().into(),
op: op!("="),
right: right.take(),
}
.into(),
);
let pat = self.fold_rest(
&mut 0,
pat.take().into(),
var_ident.clone().into(),
true,
true,
);
match pat {
Pat::Object(ObjectPat { ref props, .. }) if props.is_empty() => {}
_ => self.exprs.push(
AssignExpr {
span: *span,
left: pat.try_into().unwrap(),
op: op!("="),
right: Box::new(var_ident.clone().into()),
}
.into(),
),
}
self.exprs.push(Box::new(var_ident.into()));
*expr = SeqExpr {
span: DUMMY_SP,
exprs: mem::take(&mut self.exprs),
}
.into();
};
}
/// export var { b, ...c } = asdf2;
fn visit_mut_module_decl(&mut self, decl: &mut ModuleDecl) {
if !contains_rest(decl) {
// fast path
return;
}
match decl {
ModuleDecl::ExportDecl(ExportDecl {
span,
decl: Decl::Var(var_decl),
..
}) if var_decl.decls.iter().any(|v| v.name.is_object()) => {
let specifiers = {
let mut found: Vec<Ident> = Vec::new();
let mut finder = VarCollector { to: &mut found };
var_decl.visit_with(&mut finder);
found
.into_iter()
.map(|ident| ExportNamedSpecifier {
span: DUMMY_SP,
orig: ident.into(),
exported: None,
is_type_only: false,
})
.map(ExportSpecifier::Named)
.collect()
};
let export = NamedExport {
span: *span,
specifiers,
src: None,
type_only: false,
with: None,
};
var_decl.visit_mut_with(self);
self.vars.append(&mut var_decl.decls);
*decl = export.into();
}
_ => {
decl.visit_mut_children_with(self);
}
};
}
fn visit_mut_module_items(&mut self, n: &mut Vec<ModuleItem>) {
self.visit_mut_stmt_like(n);
}
fn visit_mut_stmts(&mut self, n: &mut Vec<Stmt>) {
self.visit_mut_stmt_like(n);
}
fn visit_mut_var_declarators(&mut self, decls: &mut Vec<VarDeclarator>) {
// fast path
if !contains_rest(decls) {
return;
}
for mut decl in decls.drain(..) {
// fast path
if !contains_rest(&decl) {
// println!("Var: no rest",);
self.vars.push(decl);
continue;
}
decl.visit_mut_children_with(self);
// if !contains_rest(&decl.name) {
// // println!("Var: no rest",);
// self.vars.push(decl);
// continue;
// }
let (var_ident, _) = match decl.name {
Pat::Ident(ref i) => (Ident::from(i), false),
_ => match decl.init {
Some(ref e) => alias_if_required(e, "ref"),
_ => (private_ident!("_ref"), true),
},
};
let has_init = decl.init.is_some();
if let Some(init) = decl.init {
match decl.name {
// Optimize { ...props } = this.props
Pat::Object(ObjectPat { props, .. })
if props.len() == 1 && matches!(props[0], ObjectPatProp::Rest(..)) =>
{
let prop = match props.into_iter().next().unwrap() {
ObjectPatProp::Rest(r) => r,
_ => unreachable!(),
};
self.vars.push(VarDeclarator {
span: prop.span(),
name: *prop.arg,
init: Some(
CallExpr {
span: DUMMY_SP,
callee: helper!(extends),
args: vec![
ObjectLit {
span: DUMMY_SP,
props: Vec::new(),
}
.as_arg(),
helper_expr!(object_destructuring_empty)
.as_call(DUMMY_SP, vec![init.as_arg()])
.as_arg(),
],
..Default::default()
}
.into(),
),
definite: false,
});
continue;
}
_ => {}
}
match *init {
// skip `z = z`
Expr::Ident(..) => {}
_ => {
// println!("Var: var_ident = init",);
self.push_var_if_not_empty(VarDeclarator {
span: DUMMY_SP,
name: var_ident.clone().into(),
init: Some(init),
definite: false,
});
}
}
}
let mut index = self.vars.len();
let mut pat =
self.fold_rest(&mut index, decl.name, var_ident.clone().into(), false, true);
match pat {
// skip `{} = z`
Pat::Object(ObjectPat { ref props, .. }) if props.is_empty() => {}
_ => {
// insert at index to create
// `var { a } = _ref, b = _object_without_properties(_ref, ['a']);`
// instead of
// `var b = _object_without_properties(_ref, ['a']), { a } = _ref;`
// println!("var: simplified pat = var_ident({:?})", var_ident);
pat.visit_mut_with(&mut PatSimplifier);
self.insert_var_if_not_empty(
index,
VarDeclarator {
name: pat,
// preserve
init: if has_init {
Some(var_ident.clone().into())
} else {
None
},
..decl
},
)
}
}
}
*decls = mem::take(&mut self.vars);
}
}
#[swc_trace]
impl ObjectRest {
fn visit_mut_stmt_like<T>(&mut self, stmts: &mut Vec<T>)
where
T: StmtLike + VisitWith<RestVisitor> + VisitMutWith<ObjectRest>,
Vec<T>: VisitMutWith<Self> + VisitWith<RestVisitor>,
{
if !contains_rest(stmts) {
return;
}
let mut buf = Vec::with_capacity(stmts.len());
for mut stmt in stmts.drain(..) {
let mut folder = ObjectRest {
config: self.config,
..Default::default()
};
stmt.visit_mut_with(&mut folder);
// Add variable declaration
// e.g. var ref
if !folder.mutable_vars.is_empty() {
buf.push(T::from(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: folder.mutable_vars,
..Default::default()
}
.into(),
));
}
if !folder.vars.is_empty() {
buf.push(T::from(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: folder.vars,
..Default::default()
}
.into(),
));
}
buf.push(stmt);
buf.extend(folder.exprs.into_iter().map(|v| v.into_stmt()).map(T::from));
}
*stmts = buf;
}
}
impl ObjectRest {
fn insert_var_if_not_empty(&mut self, idx: usize, mut decl: VarDeclarator) {
if let Some(e1) = decl.init {
if let Expr::Ident(ref i1) = *e1 {
if let Pat::Ident(ref i2) = decl.name {
if i1.to_id() == i2.to_id() {
return;
}
}
}
decl.init = Some(e1);
}
if let Pat::Object(..) | Pat::Array(..) = decl.name {
let ids: Vec<Id> = find_pat_ids(&decl.name);
if ids.is_empty() {
return;
}
}
self.vars.insert(idx, decl)
}
fn push_var_if_not_empty(&mut self, mut decl: VarDeclarator) {
if let Some(e1) = decl.init {
if let Expr::Ident(ref i1) = *e1 {
if let Pat::Ident(ref i2) = decl.name {
if i1.sym == i2.sym && i1.ctxt == i2.ctxt {
return;
}
}
}
decl.init = Some(e1);
}
if let Pat::Object(ObjectPat { ref props, .. }) = decl.name {
if props.is_empty() {
return;
}
}
self.vars.push(decl)
}
fn visit_mut_fn_like(
&mut self,
params: &mut Vec<Param>,
body: &mut BlockStmt,
) -> (Vec<Param>, BlockStmt) {
if !contains_rest(params) {
// fast-path
return (params.take(), body.take());
}
let prev_state = replace(
self,
Self {
config: self.config,
..Default::default()
},
);
let params = params
.drain(..)
.map(|mut param| {
let var_ident = private_ident!(param.span(), "_param");
let mut index = self.vars.len();
param.pat =
self.fold_rest(&mut index, param.pat, var_ident.clone().into(), false, true);
match param.pat {
Pat::Rest(..) | Pat::Ident(..) => param,
Pat::Assign(AssignPat { ref left, .. })
if left.is_ident() || left.is_rest() || left.is_array() =>
{
param
}
Pat::Assign(n) => {
let AssignPat {
span, left, right, ..
} = n;
self.insert_var_if_not_empty(
index,
VarDeclarator {
span,
name: *left,
init: Some(var_ident.clone().into()),
definite: false,
},
);
Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: AssignPat {
span,
left: var_ident.into(),
right,
}
.into(),
}
}
_ => {
// initialize snd destructure
self.insert_var_if_not_empty(
index,
VarDeclarator {
span: DUMMY_SP,
name: param.pat,
init: Some(var_ident.clone().into()),
definite: false,
},
);
Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: var_ident.into(),
}
}
}
})
.collect();
let ret = (
params,
BlockStmt {
stmts: if self.vars.is_empty() {
None
} else {
Some(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: mem::take(&mut self.vars),
..Default::default()
}
.into(),
)
}
.into_iter()
.chain(body.stmts.take())
.collect(),
..body.take()
},
);
*self = prev_state;
ret
}
fn fold_rest(
&mut self,
index: &mut usize,
pat: Pat,
obj: Box<Expr>,
use_expr_for_assign: bool,
use_member_for_array: bool,
) -> Pat {
// TODO(kdy1): Optimize when all fields are statically known.
//
// const { a: { ...bar }, b: { ...baz }, ...foo } = obj;
//
// can be
//
// const bar = _extends({}, obj.a), baz = _extends({}, obj.b), foo =
// _extends({}, obj);
if pat.is_ident() {
// panic!()
}
let ObjectPat {
span,
props,
type_ann,
..
} = match pat {
Pat::Object(pat) => pat,
Pat::Assign(n) => {
let AssignPat {
span, left, right, ..
} = n;
let left = Box::new(self.fold_rest(
index,
*left,
obj,
use_expr_for_assign,
use_member_for_array,
));
return AssignPat { span, left, right }.into();
}
Pat::Array(n) => {
let ArrayPat { span, elems, .. } = n;
let elems = elems
.into_iter()
.enumerate()
.map(|(i, elem)| {
elem.map(|elem| {
self.fold_rest(
index,
elem,
if use_member_for_array {
obj.clone().computed_member(i as f64).into()
} else {
obj.clone()
},
use_expr_for_assign,
use_member_for_array,
)
})
})
.collect();
return ArrayPat { span, elems, ..n }.into();
}
_ => return pat,
};
let mut props: Vec<ObjectPatProp> = props
.into_iter()
.map(|prop| match prop {
ObjectPatProp::Rest(n) => {
let RestPat {
arg, dot3_token, ..
} = n;
let pat = self.fold_rest(
index,
*arg,
// TODO: fix this. this is wrong
obj.clone(),
use_expr_for_assign,
true,
);
ObjectPatProp::Rest(RestPat {
dot3_token,
arg: Box::new(pat),
..n
})
}
ObjectPatProp::KeyValue(KeyValuePatProp { key, value }) => {
let (key, prop) = match key {
PropName::Ident(ref ident) => {
let ident = ident.clone();
(key, MemberProp::Ident(ident))
}
PropName::Str(Str {
ref value, span, ..
}) => {
let value = value.clone();
(key, MemberProp::Ident(IdentName::new(value, span)))
}
PropName::Num(Number { span, value, .. }) => (
key,
MemberProp::Computed(ComputedPropName {
span,
expr: Lit::Str(Str {
span,
raw: None,
value: format!("{}", value).into(),
})
.into(),
}),
),
PropName::BigInt(BigInt {
span, ref value, ..
}) => {
let value = value.clone();
(
key,
MemberProp::Computed(ComputedPropName {
span,
expr: Lit::Str(Str {
span,
raw: None,
value: format!("{}", value).into(),
})
.into(),
}),
)
}
PropName::Computed(ref c) if is_literal(&c.expr) => {
let c = c.clone();
(key, MemberProp::Computed(c))
}
PropName::Computed(c) => {
let (ident, aliased) = alias_if_required(&c.expr, "key");
if aliased {
*index += 1;
self.vars.push(VarDeclarator {
span: DUMMY_SP,
name: ident.clone().into(),
init: Some(c.expr),
definite: false,
});
}
(
PropName::Computed(ComputedPropName {
span: c.span,
expr: ident.clone().into(),
}),
MemberProp::Computed(ComputedPropName {
span: c.span,
expr: ident.into(),
}),
)
}
};
let value = Box::new(
self.fold_rest(
index,
*value,
Box::new(
MemberExpr {
span: DUMMY_SP,
obj: obj.clone(),
prop,
}
.into(),
),
use_expr_for_assign,
true,
),
);
ObjectPatProp::KeyValue(KeyValuePatProp { key, value })
}
_ => prop,
})
.collect();
match props.last() {
Some(ObjectPatProp::Rest(..)) => {}
_ => {
return ObjectPat {
span,
props,
optional: false,
type_ann,
}
.into();
}
}
let last = match props.pop() {
Some(ObjectPatProp::Rest(rest)) => rest,
_ => unreachable!(),
};
let excluded_props = excluded_props(&props);
if use_expr_for_assign {
// println!("Expr: last.arg = objectWithoutProperties()",);
self.exprs.push(
AssignExpr {
span: DUMMY_SP,
left: last.arg.try_into().unwrap(),
op: op!("="),
right: Box::new(object_without_properties(
obj,
excluded_props,
self.config.no_symbol,
)),
}
.into(),
);
} else {
// println!("Var: rest = objectWithoutProperties()",);
self.push_var_if_not_empty(VarDeclarator {
span: DUMMY_SP,
name: *last.arg,
init: Some(Box::new(object_without_properties(
obj,
excluded_props,
self.config.no_symbol,
))),
definite: false,
});
}
ObjectPat {
props,
span,
type_ann,
optional: false,
}
.into()
}
}
#[tracing::instrument(level = "info", skip_all)]
fn object_without_properties(
obj: Box<Expr>,
excluded_props: Vec<Option<ExprOrSpread>>,
no_symbol: bool,
) -> Expr {
if excluded_props.is_empty() {
return CallExpr {
span: DUMMY_SP,
callee: helper!(extends),
args: vec![
ObjectLit {
span: DUMMY_SP,
props: Vec::new(),
}
.as_arg(),
helper_expr!(object_destructuring_empty)
.as_call(DUMMY_SP, vec![obj.as_arg()])
.as_arg(),
],
..Default::default()
}
.into();
}
let excluded_props = excluded_props
.into_iter()
.map(|v| {
v.map(|v| match *v.expr {
Expr::Lit(Lit::Num(Number { span, value, .. })) => ExprOrSpread {
expr: Lit::Str(Str {
span,
raw: None,
value: value.to_string().into(),
})
.into(),
..v
},
_ => v,
})
})
.collect();
CallExpr {
span: DUMMY_SP,
callee: if no_symbol {
helper!(object_without_properties_loose)
} else {
helper!(object_without_properties)
},
args: vec![
obj.as_arg(),
if is_literal(&excluded_props) {
ArrayLit {
span: DUMMY_SP,
elems: excluded_props,
}
.as_arg()
} else {
CallExpr {
span: DUMMY_SP,
callee: ArrayLit {
span: DUMMY_SP,
elems: excluded_props,
}
.make_member(quote_ident!("map"))
.as_callee(),
args: vec![helper_expr!(to_property_key).as_arg()],
..Default::default()
}
.as_arg()
},
],
..Default::default()
}
.into()
}
#[tracing::instrument(level = "info", skip_all)]
fn excluded_props(props: &[ObjectPatProp]) -> Vec<Option<ExprOrSpread>> {
props
.iter()
.map(|prop| match prop {
ObjectPatProp::KeyValue(KeyValuePatProp { key, .. }) => match key {
PropName::Ident(ident) => Lit::Str(Str {
span: ident.span,
raw: None,
value: ident.sym.clone(),
})
.as_arg(),
PropName::Str(s) => Lit::Str(s.clone()).as_arg(),
PropName::Num(Number { span, value, .. }) => Lit::Str(Str {
span: *span,
raw: None,
value: format!("{}", value).into(),
})
.as_arg(),
PropName::BigInt(BigInt { span, value, .. }) => Lit::Str(Str {
span: *span,
raw: None,
value: format!("{}", value).into(),
})
.as_arg(),
PropName::Computed(c) => c.expr.clone().as_arg(),
},
ObjectPatProp::Assign(AssignPatProp { key, .. }) => Lit::Str(Str {
span: key.span,
raw: None,
value: key.sym.clone(),
})
.as_arg(),
ObjectPatProp::Rest(..) => unreachable!("invalid syntax (multiple rest element)"),
})
.map(Some)
.collect()
}
/// e.g.
///
/// - `{ x4: {} }` -> `{}`
struct PatSimplifier;
#[swc_trace]
impl VisitMut for PatSimplifier {
noop_visit_mut_type!(fail);
fn visit_mut_pat(&mut self, pat: &mut Pat) {
pat.visit_mut_children_with(self);
if let Pat::Object(o) = pat {
o.props.retain(|prop| {
if let ObjectPatProp::KeyValue(KeyValuePatProp { value, .. }) = prop {
match &**value {
Pat::Object(ObjectPat { props, .. }) if props.is_empty() => {
return false;
}
_ => {}
}
}
true
});
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2018/src/object_rest_spread.rs | Rust | use serde::Deserialize;
use swc_ecma_ast::Pass;
use swc_ecma_visit::visit_mut_pass;
use crate::{object_rest::ObjectRest, object_spread::ObjectSpread};
// TODO: currently swc behaves like babel with
// `ignoreFunctionLength` on
/// `@babel/plugin-proposal-object-rest-spread`
pub fn object_rest_spread(config: Config) -> impl Pass {
(
visit_mut_pass(ObjectRest {
config,
..Default::default()
}),
visit_mut_pass(ObjectSpread { config }),
)
}
#[derive(Debug, Clone, Copy, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Config {
#[serde(default)]
pub no_symbol: bool,
#[serde(default)]
pub set_property: bool,
#[serde(default)]
pub pure_getters: bool,
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2018/src/object_spread.rs | Rust | use swc_common::{util::take::Take, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::{helper, perf::Parallel};
use swc_ecma_utils::ExprFactory;
use swc_ecma_visit::{noop_visit_mut_type, VisitMut, VisitMutWith};
use swc_trace_macro::swc_trace;
use super::object_rest_spread::Config;
#[derive(Clone, Copy)]
pub(super) struct ObjectSpread {
pub config: Config,
}
impl Parallel for ObjectSpread {
fn create(&self) -> Self {
ObjectSpread {
config: self.config,
}
}
fn merge(&mut self, _: Self) {}
}
#[swc_trace]
impl VisitMut for ObjectSpread {
noop_visit_mut_type!(fail);
fn visit_mut_expr(&mut self, expr: &mut Expr) {
expr.visit_mut_children_with(self);
if let Expr::Object(ObjectLit { span, props }) = expr {
let has_spread = props.iter().any(|p| matches!(p, PropOrSpread::Spread(..)));
if !has_spread {
return;
}
let mut callee = if self.config.set_property {
helper!(extends)
} else {
helper!(object_spread)
};
// { foo, ...x } => ({ foo }, x)
let args = {
let mut buf = Vec::new();
let mut obj = ObjectLit {
span: DUMMY_SP,
props: Vec::new(),
};
let mut first = true;
for prop in props.take() {
match prop {
PropOrSpread::Prop(..) => {
// before is spread element
if !first && obj.props.is_empty() && !self.config.pure_getters {
buf = vec![Expr::Call(CallExpr {
span: DUMMY_SP,
callee: callee.clone(),
args: buf.take(),
..Default::default()
})
.as_arg()];
}
obj.props.push(prop)
}
PropOrSpread::Spread(SpreadElement { expr, .. }) => {
// Push object if it's not empty
if first || !obj.props.is_empty() {
buf.push(obj.take().as_arg());
if !first && !self.config.pure_getters {
buf = vec![Expr::Call(CallExpr {
span: DUMMY_SP,
callee: helper!(object_spread_props),
args: buf.take(),
..Default::default()
})
.as_arg()];
}
first = false;
}
buf.push(expr.as_arg());
}
}
}
if !obj.props.is_empty() {
if !self.config.pure_getters {
callee = helper!(object_spread_props);
}
buf.push(obj.as_arg());
}
buf
};
*expr = CallExpr {
span: *span,
callee,
args,
..Default::default()
}
.into();
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_compat_es2019/src/lib.rs | Rust | use swc_ecma_ast::Pass;
pub use self::optional_catch_binding::optional_catch_binding;
mod optional_catch_binding;
pub fn es2019() -> impl Pass {
optional_catch_binding()
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.