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_transforms_compat/tests/block-scoping/issue-4286/2/output.js | JavaScript | var _loop__6 = function(i__3) {
Promise.resolve().then(()=>{
console.log(`async: ${i__3}`);
});
};
for (var i__3 of [
1,
2,
3
])_loop__6(i__3);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5048/1/input.js | JavaScript | class C {
mount() {
let overrideFucNames = [
"addChild",
"addChildAt",
"removeChild",
"removeChildAt",
];
let cardWidth = 1275;
for (let v of overrideFucNames) {
//when you put this inside the for...of loop, the 'this' inside function declare will lose
let overrideTarget = this.$cardsBox;
let origiFuc = overrideTarget[v];
overrideTarget[v] = function () {
if (this.width > cardWidth) {
this.scaleX = this.scaleY = (
cardWidth / this.width
).toFixed(2);
}
origiFuc.apply(this, arguments);
};
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5048/1/output.js | JavaScript | class C__2 {
mount() {
var _this__8, _loop__9 = function(v__4) {
//when you put this inside the for...of loop, the 'this' inside function declare will lose
var overrideTarget__5 = _this__8.$cardsBox;
var origiFuc__5 = overrideTarget__5[v__4];
overrideTarget__5[v__4] = function() {
if (this.width > cardWidth__3) {
this.scaleX = this.scaleY = (cardWidth__3 / this.width).toFixed(2);
}
origiFuc__5.apply(this, arguments);
};
};
var overrideFucNames__3 = [
"addChild",
"addChildAt",
"removeChild",
"removeChildAt"
];
var cardWidth__3 = 1275;
for (var v__4 of overrideFucNames__3)_this__8 = this, _loop__9(v__4);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5048/2/input.js | JavaScript | class C extends D {
mount() {
let overrideFucNames = [
"addChild",
"addChildAt",
"removeChild",
"removeChildAt",
];
for (let v of overrideFucNames) {
setTimeout(() => super.mount(v));
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5048/2/output.js | JavaScript | class C__2 extends D {
mount() {
var _this__7, _superprop_get_mount__6, _loop__8 = function(v__4) {
setTimeout(()=>_superprop_get_mount__6().call(_this__7, v__4));
};
var overrideFucNames__3 = [
"addChild",
"addChildAt",
"removeChild",
"removeChildAt"
];
for (var v__4 of overrideFucNames__3)_this__7 = this, _superprop_get_mount__6 = ()=>super.mount, _loop__8(v__4);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5270/1/input.js | JavaScript | for (let i = 0; i < 5; i++) {
let j = Math.random();
setTimeout(() => console.log(j), 0);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5270/1/output.js | JavaScript | var _loop__5 = function(i__3) {
var j__4 = Math.random();
setTimeout(()=>console.log(j__4), 0);
};
for(var i__3 = 0; i__3 < 5; i__3++)_loop__5(i__3);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5270/2/input.js | JavaScript | for (var a = 0; a < 10; a++) {
console.log(() => a);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5270/2/output.js | JavaScript | for(var a__2 = 0; a__2 < 10; a__2++){
console.log(()=>a__2);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5270/3/input.js | JavaScript | while (foo()) {
let j = Math.random();
setTimeout(() => console.log(j), 0);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-5270/3/output.js | JavaScript | var _loop__4 = function() {
var j__3 = Math.random();
setTimeout(()=>console.log(j__3), 0);
};
while(foo())_loop__4();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6344/1/input.js | JavaScript | "use strict";
function a() { }
var te = function () {
var n = function n(e) { };
var t = null;
return {
init: function init(e) {
return t = new n(e);
}
};
}();
var he = function () {
var n = function n() {
a();
};
;
var t = null;
return {
init: function init(e) {
return t;
}
};
}(); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6344/1/output.js | JavaScript | "use strict";
function a__2() {}
var te__2 = function() {
var n__4 = function n__5(e__6) {};
var t__4 = null;
return {
init: function init__7(e__8) {
return t__4 = new n__4(e__8);
}
};
}();
var he__2 = function() {
var n__9 = function n__10() {
a__2();
};
;
var t__9 = null;
return {
init: function init__12(e__13) {
return t__9;
}
};
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6573/1/input.js | JavaScript | let funcs = [];
for (let i = 0; i < 2; i++)
for (let j = 0; j < 2; j++)
funcs.push(() => console.log(i, j));
funcs.forEach((f) => f());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6573/1/output.js | JavaScript | var _loop__7 = function(i__3) {
var _loop__6 = function(j__4) {
funcs__2.push(()=>console.log(i__3, j__4));
};
for(var j__4 = 0; j__4 < 2; j__4++)_loop__6(j__4);
};
var funcs__2 = [];
for(var i__3 = 0; i__3 < 2; i__3++)_loop__7(i__3);
funcs__2.forEach((f__5)=>f__5());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6573/2/input.js | JavaScript | let funcs = [];
for (let i in [1, 2])
for (let j in [1, 2])
funcs.push(() => console.log(i, j));
funcs.forEach((f) => f());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6573/2/output.js | JavaScript | var _loop__7 = function(i__3) {
var _loop__6 = function(j__4) {
funcs__2.push(()=>console.log(i__3, j__4));
};
for(var j__4 in [
1,
2
])_loop__6(j__4);
};
var funcs__2 = [];
for(var i__3 in [
1,
2
])_loop__7(i__3);
funcs__2.forEach((f__5)=>f__5());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6573/3/input.js | JavaScript | let funcs = [];
for (let i of [1, 2])
for (let j of [1, 2])
funcs.push(() => console.log(i, j));
funcs.forEach((f) => f());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6573/3/output.js | JavaScript | var _loop__7 = function(i__3) {
var _loop__6 = function(j__4) {
funcs__2.push(()=>console.log(i__3, j__4));
};
for (var j__4 of [
1,
2
])_loop__6(j__4);
};
var funcs__2 = [];
for (var i__3 of [
1,
2
])_loop__7(i__3);
funcs__2.forEach((f__5)=>f__5());
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-6898/1/exec.js | JavaScript | (async () => {
const arr = [
'value1',
'value2',
'value3',
];
// for (const value of arr) {
for (let i = 0; i < arr.length; i++) {
const value = arr[i];
setTimeout(() => {
console.log('value', value);
}, 0);
}
})(); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-7418/1/exec.js | JavaScript | const truc = { as: "OK" }
function x(as) {
return function g() {
const { as } = truc
console.log(as)
}
as
}
x()(); | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-7432/1/exec.js | JavaScript | (async () => {
const array = [1, 2, 3]
for (const el of array)
setTimeout(() => {
console.log(el)
}, 1)
})() | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-7989/input.js | JavaScript | async function foo(a, b) {
for (let i = 0; i < 5; i++) {
const boo = await a();
b(() => boo)
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-7989/output.js | JavaScript | async function foo__2(a__3, b__3) {
var _loop__6 = async function(i__4) {
var boo__5 = await a__3();
b__3(()=>boo__5);
};
for(var i__4 = 0; i__4 < 5; i__4++)await _loop__6(i__4);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-8148/1/input.js | JavaScript |
function _toBeMocked() {
return "I am the original function";
}
export let toBeMocked = _toBeMocked
export const mock = {
get toBeMocked() { return toBeMocked; },
set toBeMocked(mock) { toBeMocked = mock; }
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/block-scoping/issue-8148/1/output.js | JavaScript | function _toBeMocked__2() {
return "I am the original function";
}
export var toBeMocked__2 = _toBeMocked__2;
var _$mock__7 = {
get toBeMocked () {
return toBeMocked__2;
},
set toBeMocked (mock__5){
toBeMocked__2 = mock__5;
}
};
export { _$mock__7 as mock__2 };
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class-properties/issue-7561/input.js | JavaScript | class Foo {
#x;
test() {
this?.y.#x;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class-properties/issue-7561/output.js | JavaScript | var _x = /*#__PURE__*/ new WeakMap();
class Foo {
test() {
var _this, _this_y;
(_this = this) === null || _this === void 0 ? void 0 : _class_private_field_get(_this_y = _this.y, _x);
}
constructor(){
_class_private_field_init(this, _x, {
writable: true,
value: void 0
});
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class-properties/issue-8948/input.js | JavaScript | class TestCls {
foo() {
this.#bar();
this.#switch();
}
#switch() {
console.log("#switch called");
}
#bar() {
console.log("#bar called");
}
}
let a = new TestCls();
a.foo();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class-properties/issue-8948/output.js | JavaScript | var _switch = /*#__PURE__*/ new WeakSet(), _bar = /*#__PURE__*/ new WeakSet();
class TestCls {
foo() {
_class_private_method_get(this, _bar, bar).call(this);
_class_private_method_get(this, _switch, __switch).call(this);
}
constructor(){
_class_private_method_init(this, _switch);
_class_private_method_init(this, _bar);
}
}
function __switch() {
console.log("#switch called");
}
function bar() {
console.log("#bar called");
}
let a = new TestCls();
a.foo();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set.rs | Rust | use std::path::PathBuf;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_compat::class_fields_use_set::class_fields_use_set;
use swc_ecma_transforms_testing::test_fixture;
#[testing::fixture("tests/class_fields_use_set/**/input.js")]
fn fixture(input: PathBuf) {
let parent = input.parent().unwrap();
let output = parent.join("output.js");
test_fixture(
Syntax::Es(Default::default()),
&|_| class_fields_use_set(true),
&input,
&output,
Default::default(),
)
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/1/input.js | JavaScript | class Foo {
// Move class field into constructor
a = 1;
// Move private class field init into constructor to preserve execution order
#b = 2;
static c = 3;
static #d = 4;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/1/output.js | JavaScript | class Foo {
// Move private class field init into constructor to preserve execution order
#b;
static{
this.c = 3;
}
static #d = 4;
constructor(){
// Move class field into constructor
this.a = 1;
this.#b = 2;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/2/input.js | JavaScript | class Foo extends Bar {
a = 1;
#b = 2;
static c = 3;
static #d = 4;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/2/output.js | JavaScript | class Foo extends Bar {
#b;
static{
this.c = 3;
}
static #d = 4;
constructor(...args){
super(...args), this.a = 1, this.#b = 2;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/3/input.js | JavaScript | class Foo extends Bar {
a = 1;
#b = 2;
constructor() {
super();
console.log("constructor");
}
static c = 3;
static #d = 4;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/3/output.js | JavaScript | class Foo extends Bar {
#b;
constructor(){
super(), this.a = 1, this.#b = 2;
console.log("constructor");
}
static{
this.c = 3;
}
static #d = 4;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/4/input.js | JavaScript | class Foo {
a = 1;
#b = 2;
static c = 3;
static #d = 4;
foo() {
class Bar {
a = 1;
#b = 2;
static c = 3;
static #d = 4;
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/4/output.js | JavaScript | class Foo {
#b;
static{
this.c = 3;
}
static #d = 4;
foo() {
class Bar {
#b;
static{
this.c = 3;
}
static #d = 4;
constructor(){
this.a = 1;
this.#b = 2;
}
}
}
constructor(){
this.a = 1;
this.#b = 2;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/5/input.js | JavaScript | class Foo {
[(console.log(1), 1)] = 1;
[Symbol.iterator] = 2;
static {
console.log("Foo");
}
[(console.log(2), 2)] = 1;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/class_fields_use_set/basic/5/output.js | JavaScript | let prop, prop1;
class Foo {
static{
prop = (console.log(1), 1);
prop1 = (console.log(2), 2);
}
static{
console.log("Foo");
}
constructor(){
this[prop] = 1;
this[Symbol.iterator] = 2;
this[prop1] = 1;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/create-super-1/exec.js | JavaScript | const UnknownNativeClass = Array;
class Foo extends UnknownNativeClass {}
new Foo();
console.log("PASS");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/create-super-1/input.js | JavaScript | class Foo extends UnknownNativeClass {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/create-super-1/output.js | JavaScript | let Foo = /*#__PURE__*/ function(UnknownNativeClass1) {
"use strict";
_inherits(Foo, UnknownNativeClass1);
function Foo() {
_class_call_check(this, Foo);
return _call_super(this, Foo, arguments);
}
return Foo;
}(UnknownNativeClass);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-1959/1/output.js | JavaScript | let Extended = /*#__PURE__*/ function(Base1) {
"use strict";
_inherits(Extended, Base1);
var _super = _create_super(Extended);
function Extended() {
_class_call_check(this, Extended);
return _super.apply(this, arguments);
}
_create_class(Extended, [
{
key: "getNext",
value: function getNext() {
return _get(_get_prototype_of(Extended.prototype), "getNext", this).call(this, 114514) + 114514;
}
}
]);
return Extended;
}(Base);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-1959/2/output.js | JavaScript | let Extended = /*#__PURE__*/ function(Base1) {
"use strict";
_inherits(Extended, Base1);
var _super = _create_super(Extended);
function Extended() {
_class_call_check(this, Extended);
return _super.apply(this, arguments);
}
_create_class(Extended, [
{
key: "getNext",
value: function getNext() {
return _get(_get_prototype_of(Extended.prototype), "getNext", this).call(this, 114514);
}
}
]);
return Extended;
}(Base);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-2071/case1/exec.js | JavaScript | const sleep = (ms) =>
new Promise((resolve, reject) => {
setTimeout(() => resolve(), ms);
});
class Project {
constructor(name) {
this.name = name;
}
}
Project.f = async function () {
await sleep(100);
console.log(this["a"]);
return new this("a");
};
Project.f().then((project) => {
console.log(project.name);
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-2071/case2/exec.js | JavaScript | const sleep = (ms) =>
new Promise((resolve, reject) => {
setTimeout(() => resolve(), ms);
});
class Project {
constructor(name) {
this.name = name;
}
static async g() {
await sleep(100);
console.log(this["a"]);
return new this("a");
}
}
Project.g().then((project) => {
console.log(project.name);
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-2228/case1/exec.js | JavaScript | class Foo {}
class Bar extends Foo {
events = {
"abc: click": function abcClick() {
this.data = 123;
console.log(this);
},
};
setData() {
this.data = 456;
}
}
const bar = new Bar();
console.log(bar.data);
console.log(bar.events);
console.log(bar.events["abc: click"]());
console.log(bar.data);
bar.setData();
console.log(bar.data);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-2476/1/exec.js | JavaScript | class Foo {
static #_ = (() => {
this.bar = "3";
})();
}
console.log(Foo.bar);
console.log(new Foo().bar);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-3106/1/exec.js | JavaScript | class ValidationStrategy {
static "object?"(value) {
return 1;
}
static "string!"(value) {
return 2;
}
static "eval?"(value) {
return 3;
}
static "arguments!"(value) {
return 3;
}
}
console.log(ValidationStrategy.prototype["string!"]);
console.log(ValidationStrategy.prototype["eval?"]);
console.log(ValidationStrategy.prototype["arguments!"]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-3700/exec.js | JavaScript | class A {
#a = 1n;
static #b = 2n;
get #c() {
return this.#a;
}
set #c(v) {
this.#a = v;
}
static get #d() {
return this.#b;
}
static set #d(v) {
this.#b = v;
}
foo() {
let a = this.#a++;
a = ++this.#a;
let b = this.#c++;
b = ++this.#c;
console.log(a, b);
}
static bar() {
let d = this.#d++;
d = ++this.#d;
let e = A.#d++;
e = ++A.#d;
console.log(d, e);
}
}
const a = new A();
a.foo();
A.bar();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-3700/input.js | JavaScript | class A {
#a = 1n;
static #b = 2n;
get #c() {
return this.#a;
}
set #c(v) {
this.#a = v;
}
static get #d() {
return this.#b;
}
static set #d(v) {
this.#b = v;
}
foo() {
let a = this.#a++;
a = ++this.#a;
let b = this.#c++;
b = ++this.#c;
console.log(a, b);
}
static bar() {
let d = this.#d++;
d = ++this.#d;
let e = A.#d++;
e = ++A.#d;
console.log(d, e);
}
}
const a = new A();
a.foo();
A.bar();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-3700/output.js | JavaScript | var _a = /*#__PURE__*/ new WeakMap(), _c = /*#__PURE__*/ new WeakMap();
let A = /*#__PURE__*/ function() {
"use strict";
function A() {
_class_call_check(this, A);
_class_private_field_init(this, _c, {
get: get_c,
set: set_c
});
_class_private_field_init(this, _a, {
writable: true,
value: 1n
});
}
_create_class(A, [
{
key: "foo",
value: function foo() {
let a = _class_private_field_update(this, _a).value++;
a = ++_class_private_field_update(this, _a).value;
let b = _class_private_field_update(this, _c).value++;
b = ++_class_private_field_update(this, _c).value;
console.log(a, b);
}
}
], [
{
key: "bar",
value: function bar() {
let d = _class_static_private_field_update(this, A, _d).value++;
d = ++_class_static_private_field_update(this, A, _d).value;
let e = _class_static_private_field_update(A, A, _d).value++;
e = ++_class_static_private_field_update(A, A, _d).value;
console.log(d, e);
}
}
]);
return A;
}();
var _d = {
get: get_d,
set: set_d
};
var _b = {
writable: true,
value: 2n
};
function get_c() {
return _class_private_field_get(this, _a);
}
function set_c(v) {
_class_private_field_set(this, _a, v);
}
function get_d() {
return _class_static_private_field_spec_get(this, A, _b);
}
function set_d(v) {
_class_static_private_field_spec_set(this, A, _b, v);
}
const a = new A();
a.foo();
A.bar();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-5029/1/input.js | JavaScript | class A {
static b() {}
static get b() {}
static set b(b) {}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-5029/1/output.js | JavaScript | let A = /*#__PURE__*/ function() {
"use strict";
function A() {
_class_call_check(this, A);
}
_create_class(A, null, [
{
key: "b",
get: function() {},
set: function(b) {}
}
]);
return A;
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-5029/2/input.js | JavaScript | class A {
"b"() {}
get b() {}
set b(b) {}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-5029/2/output.js | JavaScript | let A = /*#__PURE__*/ function() {
"use strict";
function A() {
_class_call_check(this, A);
}
_create_class(A, [
{
key: "b",
get: function() {},
set: function(b) {}
}
]);
return A;
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-5029/3/input.js | JavaScript | class A {
get b() {}
set b(b) {}
b() {}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-5029/3/output.js | JavaScript | let A = /*#__PURE__*/ function() {
"use strict";
function A() {
_class_call_check(this, A);
}
_create_class(A, [
{
key: "b",
value: function b() {}
}
]);
return A;
}();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-6356/input.js | JavaScript | class x {
[this[0]]() {}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/issue-6356/output.js | JavaScript | let x = /*#__PURE__*/ function(_prop) {
"use strict";
function x() {
_class_call_check(this, x);
}
_create_class(x, [
{
key: _prop,
value: function() {}
}
]);
return x;
}(this[0]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/next-30174/1/exec.js | JavaScript | class A {
static get foo() { return 42; }
}
class B extends A {
static foo = 427;
}
console.log(A.foo, B.foo) | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/next-31627/1/input.js | JavaScript | import { useEffect } from "react";
import { select, selectAll } from "d3-selection";
export default function Home() {
useEffect(() => {
new MyClass();
}, []);
return {};
}
class MyClass {
constructor() {
selectAll(".group").each(function () {
select(this).selectAll("path");
});
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/classes/next-31627/1/output.js | JavaScript | import { useEffect } from "react";
import { select, selectAll } from "d3-selection";
export default function Home() {
useEffect(()=>{
new MyClass();
}, []);
return {};
}
let MyClass = function MyClass() {
"use strict";
_class_call_check(this, MyClass);
selectAll(".group").each(function() {
select(this).selectAll("path");
});
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/destructuring/7776/input.js | JavaScript | function fn([
{ foo, ...flags },
{ bar }
]) {
console.log(flags.rangeChanged);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/destructuring/7776/output.js | JavaScript | function fn(_param) {
var _param1 = _sliced_to_array(_param, 2), foo = _param1[0].foo, bar = _param1[1].bar, flags = _object_without_properties(_param[0], [
"foo"
]);
console.log(flags.rangeChanged);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/destructuring/pr-8470/input.js | JavaScript | export class A {
constructor(t, { a, b = 6, c } = {}) {}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/destructuring/pr-8470/output.js | JavaScript | export class A {
constructor(t, ref){
let _ref = ref === void 0 ? {} : ref, a = _ref.a, _ref_b = _ref.b, b = _ref_b === void 0 ? 6 : _ref_b, c = _ref.c;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_arrow.rs | Rust | use std::path::PathBuf;
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::es2015::arrow;
use swc_ecma_transforms_testing::{compare_stdout, test_fixture};
fn tr() -> impl Pass {
let unresolved = Mark::new();
let global = Mark::new();
(resolver(unresolved, global, false), arrow(unresolved))
}
compare_stdout!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
arguments_nested_arrow,
"
function test() {
console.log(arguments[0]);
return () => {
console.log(arguments[0]);
return () => {
console.log(arguments[0])
};
}
}
test()(1)(2);
"
);
compare_stdout!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
arguments_nested_fn,
"
function test() {
console.log(arguments[0]);
return () => {
console.log(arguments[0]);
return function() {
console.log(arguments[0]);
return () => {
console.log(arguments[0])
};
};
}
}
test()(1)(2)(3);
"
);
#[testing::fixture("tests/arrow/**/input.js")]
fn fixture(input: PathBuf) {
let output = input.with_file_name("output.js");
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
(
resolver(unresolved_mark, Mark::new(), false),
arrow(unresolved_mark),
)
},
&input,
&output,
Default::default(),
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_block_scoping.rs | Rust | use std::{fs::read_to_string, path::PathBuf};
use swc_common::{Mark, SyntaxContext};
use swc_ecma_ast::{Ident, Pass, PropName, TsQualifiedName};
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015,
es2015::{block_scoping, for_of::for_of},
es2017::async_to_generator,
};
use swc_ecma_transforms_testing::{compare_stdout, test, test_exec, test_fixture, Tester};
use swc_ecma_visit::{visit_mut_obj_and_computed, visit_mut_pass, VisitMut, VisitMutWith};
fn tr() -> impl Pass {
let unresolved_mark = Mark::new();
(
resolver(unresolved_mark, Mark::new(), false),
block_scoping(unresolved_mark),
)
}
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
for_loop,
"for (const key in obj) {
const bar = obj[key];
let qux;
let fog;
if (Array.isArray(bar)) {
qux = bar[0];
fog = bar[1];
} else {
qux = bar;
}
baz(key, qux, fog);
}"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
for_let_loop,
"let functions = [];
for (let i = 0; i < 10; i++) {
functions.push(function() {
console.log(i);
});
}
functions[0]();
functions[7]();"
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
for_let_loop_exec,
"let functions = [];
for (let i = 0; i < 10; i++) {
functions.push(function() {
return i;
});
}
expect(functions[0]()).toBe(0);
expect(functions[7]()).toBe(7);
"
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
for_let_of_exec,
"let functions = [];
for (let i of [1, 3, 5, 7, 9]) {
functions.push(function() {
return i;
});
}
expect(functions[0]()).toBe(1);
expect(functions[1]()).toBe(3);
"
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|_| (for_of(Default::default()), block_scoping(Mark::new())),
issue_609_1,
"let functions = [];
for (let i of [1, 3, 5, 7, 9]) {
functions.push(function() {
return i;
});
}
expect(functions[0]()).toBe(1);
expect(functions[1]()).toBe(3);
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
issue_662,
"function foo(parts) {
let match = null;
for (let i = 1; i >= 0; i--) {
for (let j = 0; j >= 0; j--) {
match = parts[i][j];
if (match) {
break;
}
}
if (match) {
break;
}
}
return match;
}
foo();"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
issue_686,
"module.exports = function(values) {
var vars = [];
var elem = null, name, val;
for (var i = 0; i < this.elements.length; i++) {
elem = this.elements[i];
name = elem.name;
if (!name) continue;
val = values[name];
if (val == null) val = '';
switch (elem.type) {
case 'submit':
break;
case 'radio':
case 'checkbox':
elem.checked = val.some(function(str) {
return str.toString() == elem.value;
});
break;
case 'select-multiple':
elem.fill(val);
break;
case 'textarea':
elem.innerText = val;
break;
case 'hidden':
break;
default:
if (elem.fill) {
elem.fill(val);
} else {
elem.value = val;
}
break;
}
}
return vars;
};"
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
issue_723_1,
"function foo() {
const lod = { 0: { mig: 'bana' }};
for (let i = 0; i < 1; i++) {
const { mig } = lod[i];
return false;
(zap) => zap === mig;
}
return true;
}
expect(foo()).toBe(false);
"
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::fresh(Mark::root());
es2015::es2015(mark, Some(comments.clone()), Default::default())
},
issue_723_2,
"function foo() {
const lod = { 0: { mig: 'bana' }};
for (let i = 0; i < 1; i++) {
const { mig } = lod[i];
return false;
(zap) => zap === mig;
}
return true;
}
expect(foo()).toBe(false);
"
);
test!(
Syntax::default(),
|Tester { comments, .. }| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
es2015::es2015(unresolved_mark, Some(comments.clone()), Default::default()),
)
},
issue_1022_1,
"
for (let i = 0; i < 5; i++) {
console.log(i++, [2].every(x => x != i))
}
"
);
test!(
Syntax::default(),
|Tester { comments, .. }| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
es2015::es2015(unresolved_mark, Some(comments.clone()), Default::default()),
)
},
issue_1022_2,
"
for (let i = 0; i < 5; i++) {
console.log(i++, [2].every(x => x != i))
if (i % 2 === 0) continue
}
"
);
test!(
Syntax::default(),
|Tester { comments, .. }| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
es2015::es2015(unresolved_mark, Some(comments.clone()), Default::default()),
)
},
issue_1022_3,
"
for (let i = 0; i < 5; i++) {
console.log(i++, [2].every(x => x != i))
if (i % 2 === 0) break
}
"
);
test!(
Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::fresh(Mark::root());
es2015::es2015(mark, Some(comments.clone()), Default::default())
},
issue_1021_1,
"
class C {
m() {
for (let x = 0; x < 10; x++) console.log(this, y => y != x)
}
}
"
);
test!(
Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::fresh(Mark::root());
es2015::es2015(mark, Some(comments.clone()), Default::default())
},
issue_1036_1,
"
async function foo() {
await Promise.all([[1], [2], [3]].map(
async ([a]) => Promise.resolve().then(() => a * 2))
)
}
"
);
test!(
Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), mark),
es2015::es2015(mark, Some(comments.clone()), Default::default()),
)
},
issue_1036_2,
"
async function foo() {
await Promise.all([[1], [2], [3]].map(
async ([a]) => Promise.resolve().then(() => a * 2))
)
}
"
);
test_exec!(
Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), mark),
es2015::es2015(mark, Some(comments.clone()), Default::default()),
)
},
issue_1036_3,
"
const x = async function() {
return await Promise.all([[1], [2], [3]].map(
async ([a]) => Promise.resolve().then(() => a * 2))
)
};
return x().then(x => {
expect(x).toEqual([2, 4, 6])
})
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
issue_1231_1,
"
function combineOverlappingMatches(matches) {
let hasOverlaps = false
for (let i = matches.length - 1; i >= 0; i--) {
let currentMatch = matches[i]
let overlap = matches.find(match => {
return match !== currentMatch && match.itemsType === currentMatch.itemsType
})
if (overlap) {
hasOverlaps = true
matches.splice(i, 1)
}
}
if (hasOverlaps) {
combineOverlappingMatches(matches)
}
}
combineOverlappingMatches([1])
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
issue_1415_1,
"
export function test(items) {
const infoMap = new WeakMap();
for (let i = 0; i < items.length; i += 1) {
const item = items[i];
let info;
switch (item.type) {
case 'branch1':
info = item.method1();
break;
case 'branch2':
info = item.method2();
break;
case 'branch3':
info = item.method3(
Object.fromEntries(
item.subItems.map((t) => [item.alias ?? t.name, getInfo(t)])
)
);
break;
default:
throw new Error('boom');
}
infoMap.set(item, info); // important
}
function getInfo(item) {
if (!infoMap.has(item)) {
throw new Error('no info yet');
}
return infoMap.get(item);
}
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::new();
(
resolver(mark, Mark::new(), false),
es2015::es2015(mark, Some(comments.clone()), Default::default()),
)
},
arguments_loop,
"
function test() {
for (var i = 0; i < arguments.length; i++) {
var arg = arguments[i];
console.log((() => arg)());
}
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::fresh(Mark::root());
es2015::es2015(mark, Some(comments.clone()), Default::default())
},
arguments_loop_member,
"
function test(a) {
for (var i = 0; i < a.arguments.length; i++) {
var arg = a.arguments[i];
console.log((() => arg)());
}
}
"
);
compare_stdout!(
::swc_ecma_parser::Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::fresh(Mark::root());
(
resolver(mark, Mark::new(), false),
es2015::es2015(mark, Some(comments.clone()), Default::default()),
)
},
arguments_arrow,
"
function test() {
for (var i = 0; i < arguments.length; i++) {
console.log((() => arguments[i])());
}
}
test(1, 2, 3);
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|Tester { comments, .. }| {
let mark = Mark::fresh(Mark::root());
es2015::es2015(mark, Some(comments.clone()), Default::default())
},
arguments_function,
"
function test() {
for (var i = 0; i < arguments.length; i++) {
console.log((function () { return arguments[i] })());
}
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
issue_1462_1,
"
export default function _object_spread(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === 'function') {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function (key) {
defineProperty(target, key, source[key]);
});
}
return target;
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
issue_2027_1,
"
const keys = {
a: 1,
b: 2,
}
const controller = {}
for (const key in keys) {
controller[key] = (c, ...d) => {
console.log(keys[key])
}
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|t| {
let mark = Mark::fresh(Mark::root());
es2015(mark, Some(t.comments.clone()), Default::default())
},
issue_2027_2,
"
const keys = {
a: 1,
b: 2,
}
const controller = {}
for (const key in keys) {
controller[key] = (c, ...d) => {
console.log(keys[key])
}
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
issue_2998_1,
"
let a = 5;
for (let b = 0; b < a; b++) {
let c = 0, b = 10, d = 100;
console.log(b);
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
issue_2998_2,
"
for (var a; ;) { }
for (var a = ['a', 'b']; ;) { }
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
issue_4196,
"
for (let i = 0; i < 2; i++) {
if (i === 0) continue
if (i === 1) break
[1].forEach((_) => {
console.log(i)
})
}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| block_scoping(Mark::new()),
labeled_break,
"
a:
b:
for (let i = 0; i < 2; i++) {
if (i === 0) continue a
if (i === 1) break b
[1].forEach((_) => {
console.log(i)
})
}
"
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
issue_2998_3,
"let a = 5;
const expected = [];
for (let b = 0; b < a; b++) {
let c = 0, b = 10, d = 100;
expected.push(b);
}
expect(expected).toEqual([10,10,10,10,10]);
"
);
#[testing::fixture("tests/block-scoping/**/exec.js")]
fn exec(input: PathBuf) {
let input = read_to_string(input).unwrap();
compare_stdout(
Default::default(),
|_| {
let unresolved_mark = Mark::new();
(
resolver(unresolved_mark, Mark::new(), false),
block_scoping(unresolved_mark),
)
},
&input,
);
compare_stdout(
Default::default(),
|t| {
let unresolved_mark = Mark::new();
(
resolver(unresolved_mark, Mark::new(), false),
es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
&input,
);
}
#[testing::fixture("tests/block-scoping/**/input.js")]
fn fixture(input: PathBuf) {
let output = input.with_file_name("output.js");
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
(
resolver(unresolved_mark, Mark::new(), false),
block_scoping(unresolved_mark),
visit_mut_pass(TsHygiene { unresolved_mark }),
)
},
&input,
&output,
Default::default(),
);
}
struct TsHygiene {
unresolved_mark: Mark,
}
impl VisitMut for TsHygiene {
visit_mut_obj_and_computed!();
fn visit_mut_ident(&mut self, i: &mut Ident) {
if SyntaxContext::empty().apply_mark(self.unresolved_mark) == i.ctxt {
println!("ts_hygiene: {} is unresolved", i.sym);
return;
}
let ctxt = format!("{:?}", i.ctxt).replace('#', "");
i.sym = format!("{}__{}", i.sym, ctxt).into();
i.ctxt = SyntaxContext::empty();
}
fn visit_mut_prop_name(&mut self, n: &mut PropName) {
if let PropName::Computed(n) = n {
n.visit_mut_with(self);
}
}
fn visit_mut_ts_qualified_name(&mut self, q: &mut TsQualifiedName) {
q.left.visit_mut_with(self);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_classes.rs | Rust | use std::{fs::read_to_string, path::PathBuf};
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015,
es2015::{arrow, block_scoping, classes, classes::Config, spread},
es2016, es2017, es2018, es2022,
es2022::class_properties,
};
use swc_ecma_transforms_testing::{compare_stdout, test, test_exec, test_fixture, Tester};
fn syntax() -> Syntax {
Syntax::default()
}
fn tr(_: &Tester) -> impl Pass {
classes(Default::default())
}
fn spec_tr(_: &Tester) -> impl Pass {
let unresolved_mark = Mark::new();
(
resolver(unresolved_mark, Mark::new(), false),
classes(Default::default()),
spread(Default::default()),
block_scoping(unresolved_mark),
)
}
test!(
syntax(),
|t| tr(t),
bigint_literial_methods,
"
class Foo {
1n() {}
get 2n() {}
set 3n(x) {}
}
"
);
test!(
syntax(),
|t| tr(t),
issue_189,
r#"
class HomePage extends React.Component {}
"#
);
test!(
syntax(),
|t| tr(t),
custom_singleton,
r#"
let singleton;
class Sub extends Foo {
constructor() {
if (singleton) {
return singleton;
}
singleton = super();
}
}
"#
);
test!(
syntax(),
|t| tr(t),
custom_native,
r#"
class List extends Array {}
"#
);
test_exec!(
syntax(),
|t| tr(t),
custom_nested,
r#"
class Hello{
constructor(){
return {
toString () {
return 'hello';
}
};
}
}
class Outer extends Hello{
constructor(){
var _ref = super();
class Inner{
constructor(){
this[_ref] = 'hello';
}
}
return new Inner();
}
}
expect(new Outer().hello).toBe('hello');
"#
);
// spec_constructor_only
test!(
syntax(),
|t| spec_tr(t),
spec_constructor_only,
r#"
class Foo {
constructor() {
}
}
"#
);
// extend_builtins_wrap_native_super
// spec_name_method_collision
// exec_super
// regression_5769_exec
test_exec!(
syntax(),
|t| tr(t),
regression_5769_exec,
r#"
class Point {
getX() {
expect(this.x).toBe(3); // C
}
}
class ColorPoint extends Point {
constructor() {
super();
this.x = 2;
super.x = 3;
expect(this.x).toBe(3); // A
expect(super.x).toBeUndefined(); // B
}
m() {
this.getX()
}
}
const cp = new ColorPoint();
cp.m();
"#
);
// spec_this_not_allowed_before_super_in_derived_classes_5_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_5_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
Foo[this];
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// spec_statement
test!(
// We don't use function-name pass
ignore,
syntax(),
|t| spec_tr(t),
spec_statement,
r#"
var BaseView = class BaseView {
constructor() {
this.autoRender = true;
}
}
var BaseView = class {
constructor() {
this.autoRender = true;
}
}
var BaseView = class {
foo() {
this.autoRender = true;
}
}
"#
);
// get_set_set_semantics_getter_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_set_semantics_getter_defined_on_parent,
r#"
class Base {
get test() {
return 1;
}
};
class Obj extends Base {
set() {
return super.test = 3;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(() => {
// this requires helpers to be in file (not external), so they
// are in "strict" mode code.
obj.set();
}).toThrow();
expect(Base.prototype.test).toBe(1);
expect(Obj.prototype.test).toBe(2);
expect(obj.test).toBe(2);
"#
);
// spec_derived_constructor_must_call_super
test!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_must_call_super,
r#"
class Foo extends Bar {
constructor() {
}
}
"#
);
// get_set_get_semantics_data_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_get_semantics_data_defined_on_parent,
r#"
class Base {
}
Base.prototype.test = 1;
class Obj extends Base {
get() {
return super.test;
}
}
Obj.prototype.test = 2;
const obj = new Obj();
expect(obj.test).toBe(2);
expect(obj.get()).toBe(1);
"#
);
// extend_builtins_spec
// spec_super_reference_before_in_lambda_2
// regression_8499
test!(
syntax(),
|t| tr(t),
regression_8499,
r#"
// Pretend that `Reflect.construct` isn't supported.
this.Reflect = undefined;
this.HTMLElement = function() {
// Here, `this.HTMLElement` is this function, not the original HTMLElement
// constructor. `this.constructor` should be this function too, but isn't.
constructor = this.constructor;
};
var constructor;
class CustomElement extends HTMLElement {};
new CustomElement();
expect(constructor).toBe(CustomElement);
"#
);
// regression_5817
test!(
syntax(),
|t| (tr(t), arrow(Mark::new())),
regression_5817,
r#"
class A extends B {
constructor() {
super();
this.arrow1 = (x) => { return x; };
this.arrow2 = (x) => x;
}
}
"#
);
// spec_super_reference_before_in_lambda_3
// get_set_set_semantics_not_defined_on_parent_setter_on_obj
test!(
syntax(),
|t| tr(t),
get_set_set_semantics_not_defined_on_parent_setter_on_obj,
r#"
class Base {
}
let value = 2;
class Obj extends Base {
set test(v) {
expect(this).toBe(obj);
value = v;
}
set() {
return super.test = 3;
}
}
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBeUndefined();
expect(value).toBe(2);
expect(obj.test).toBe(3);
"#
);
// get_set_get_semantics_setter_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_get_semantics_setter_defined_on_parent,
r#"
class Base {
set test(v) {
throw new Error("called");
}
}
class Obj extends Base {
get() {
return super.test;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.test).toBe(2);
expect(obj.get()).toBeUndefined();
"#
);
// spec_this_not_allowed_before_super_in_derived_classes_4
test!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_4,
r#"
class Foo extends Bar {
constructor() {
const fn = () => this;
super();
fn();
}
}
"#
);
// spec_calling_super_properties
test!(
syntax(),
|t| spec_tr(t),
spec_calling_super_properties,
r#"
class Test extends Foo {
constructor() {
super();
super.test.whatever();
super.test();
}
static test() {
return super.wow();
}
}
"#
);
// spec_super_reference_before_bare_super
// spec_super_reference_before_bare_super_inline
// spec_instance_getter_and_setter
test!(
syntax(),
|t| spec_tr(t),
spec_instance_getter_and_setter,
r#"
class Test {
get test() {
return 5 + 5;
}
set test(val) {
this._test = val;
}
}
"#
);
// regression_2941
test!(
// Module
ignore,
syntax(),
|t| tr(t),
regression_2941,
r#"
export default class {}
"#
);
// regression_t2494
test!(
syntax(),
|t| tr(t),
regression_t2494,
r#"
var x = {
Foo: class extends Foo {}
};
"#
);
// spec_inferred_expression_name
test!(
syntax(),
|t| spec_tr(t),
spec_inferred_expression_name,
r#"
var o = { foo: class foo {} };
"#
);
// regression_8499_exec
test_exec!(
// Wrong test (babel + jest fails)
ignore,
syntax(),
|t| tr(t),
regression_8499_exec,
r#"
// Pretend that `Reflect.construct` isn't supported.
this.Reflect = undefined;
this.HTMLElement = function() {
// Here, `this.HTMLElement` is this function, not the original HTMLElement
// constructor. `this.constructor` should be this function too, but isn't.
constructor = this.constructor;
};
var constructor;
class CustomElement extends HTMLElement {};
new CustomElement();
expect(constructor).toBe(CustomElement);
"#
);
// spec_default_super
test!(
syntax(),
|t| spec_tr(t),
spec_default_super,
r#"
class Test {
constructor() {
return super.constructor;
}
static test() {
return super.constructor;
}
}
// Instances
expect(Object.getPrototypeOf(Test.prototype)).toBe(Object.prototype);
expect(new Test()).toBe(Object);
// Static
expect(Object.getPrototypeOf(Test)).toBe(Function.prototype);
expect(Test.test()).toBe(Function);
"#
);
// spec_default_super
test!(
syntax(),
|t| spec_tr(t),
spec_default_super_constructor,
r#"
class Test {
constructor() {
return super.constructor;
}
}
"#
);
// get_set_get_semantics_getter_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_get_semantics_getter_defined_on_parent,
r#"
class Base {
get test() {
expect(this).toBe(obj);
return 1;
}
}
class Obj extends Base {
get() {
return super.test;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.test).toBe(2);
expect(obj.get()).toBe(1);
"#
);
// spec
// spec_this_not_allowed_before_super_in_derived_classes
test!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes,
r#"
class Foo extends Bar {
constructor() {
this.foo = "bar";
super();
}
}
"#
);
// get_set_call_semantics_getter_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_call_semantics_getter_defined_on_parent,
r#"
class Base {
get test() {
expect(this).toBe(obj);
return function(...args) {
expect(this).toBe(obj);
expect(args).toEqual([1, 2, 3]);
return 1;
};
}
}
class Obj extends Base {
call() {
super.test(1, 2, 3);
super.test(1, ...[2, 3]);
super.test(...[1, 2, 3]);
return super.test(...arguments);
}
test() {
throw new Error("called");
}
}
const obj = new Obj();
expect(obj.call(1, 2, 3)).toBe(1);
"#
);
// spec_derived_constructor_must_call_super_4_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_must_call_super_4_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
const fn = () => super();
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// exec_retain_no_call_on
// spec_export_default
test!(
syntax(),
|t| spec_tr(t),
spec_export_default,
r#"
export default class Foo {}
"#
);
// get_set_call_semantics_data_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_call_semantics_data_defined_on_parent,
r#"
class Base {
test(...args) {
expect(this).toBe(obj);
expect(args).toEqual([1, 2, 3]);
return 1;
}
}
class Obj extends Base {
call() {
super.test(1, 2, 3);
super.test(1, ...[2, 3]);
super.test(...[1, 2, 3]);
return super.test(...arguments);
}
test() {
throw new Error("called");
}
}
const obj = new Obj();
expect(obj.call(1, 2, 3)).toBe(1);
"#
);
// spec_static
test!(
syntax(),
|t| spec_tr(t),
spec_static,
r#"
class A {
static a() {
}
static get b(){
}
static set b(b){
}
}
"#
);
// regression_t6755
// get_set_memoized_update
test!(
syntax(),
|t| tr(t),
get_set_memoized_update,
r#"
class Base {}
Object.defineProperty(Base.prototype, 0, {
value: 0,
writable: true,
configurable: true,
});
Object.defineProperty(Base.prototype, 1, {
value: 1,
writable: true,
configurable: true,
});
let i = 0;
const proper = {
get prop() {
return i++;
},
};
class Obj extends Base {
update() {
super[proper.prop]++;
}
update2() {
super[i]++;
}
}
const obj = new Obj();
obj.update();
expect(i).toBe(1);
expect(obj[0]).toBe(1);
expect(obj[1]).toBe(1);
obj.update2();
expect(i).toBe(1);
expect(obj[0]).toBe(1);
expect(obj[1]).toBe(2);
"#
);
// spec_nested_class_super_property_in_key
test!(
syntax(),
|t| spec_tr(t),
spec_nested_class_super_property_in_key,
r#"
class Hello {
toString() {
return 'hello';
}
}
class Outer extends Hello {
constructor() {
super();
class Inner {
[super.toString()]() {
return 'hello';
}
}
return new Inner();
}
}
expect(new Outer().hello()).toBe('hello');
"#
);
// spec_super_reference_in_prop_expression
test!(
syntax(),
|t| spec_tr(t),
spec_super_reference_in_prop_exression,
r#"
class Foo extends Bar {
constructor() {
super[super().method]();
}
}
"#
);
// spec_super_reference_before_in_lambda_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_super_reference_before_in_lambda_exec,
r#"
class Bar {
test() {}
}
class Foo extends Bar {
constructor() {
const t = () => super.test()
super();
}
}
new Foo();
"#
);
// spec_nested_class_super_call_in_key_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_nested_class_super_call_in_key_exec,
r#"
class Hello {
constructor() {
return {
toString() {
return 'hello';
},
};
}
}
class Outer extends Hello {
constructor() {
class Inner {
[super()]() {
return 'hello';
}
}
return new Inner();
}
}
expect(new Outer().hello()).toBe('hello');
"#
);
// spec_this_not_allowed_before_super_in_derived_classes_4_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_4_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
const fn = () => this;
super();
fn();
}
}
new Foo();
"#
);
// spec_this_not_allowed_before_super_in_derived_classes_2
test!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_2,
r#"
class Foo extends Bar {
constructor() {
super(this);
}
}
"#
);
// spec_accessing_super_properties
test!(
syntax(),
|t| spec_tr(t),
spec_accessing_super_properties,
r#"
class Test extends Foo {
constructor() {
super();
super.test;
super.test.whatever;
}
}
"#
);
// exec_shadow
// spec_computed_methods
test!(
syntax(),
|t| spec_tr(t),
spec_computed_methods,
r#"
class Foo {
foo() {}
"foo"() {}
[bar]() {}
[bar + "foo"]() {}
}
"#
);
// extend_builtins_shadowed
// get_set_set_semantics_data_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_set_semantics_data_defined_on_parent,
r#"
class Base {
}
Object.defineProperty(Base.prototype, 'test', {
value: 1,
writable: true,
configurable: true,
});
class Obj extends Base {
set() {
return super.test = 3;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBe(1);
expect(Obj.prototype.test).toBe(2);
expect(obj.test).toBe(3);
"#
);
// get_set_set_semantics_not_defined_on_parent_getter_on_obj
test!(
syntax(),
|t| tr(t),
get_set_set_semantics_not_defined_on_parent_getter_on_obj,
r#"
class Base {
}
class Obj extends Base {
get test() { }
set() {
return super.test = 3;
}
}
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBeUndefined();
expect(obj.test).toBe(3);
"#
);
// get_set
// spec_returning_from_derived_constructor_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_returning_from_derived_constructor_exec,
r#"
class Foo {
constructor() {
return { x: 1 };
}
}
expect(new Foo().x).toBe(1);
class Bar extends Foo {
constructor() {
super();
return;
}
}
expect(new Bar().x).toBe(1);
class Bar2 extends Foo {
constructor() {
super();
expect(this.x).toBe(1);
return { x: 2 };
}
}
expect(new Bar2().x).toBe(2);
let singleton;
class Sub extends Foo {
constructor() {
if (singleton) {
return singleton;
}
singleton = super();
}
}
let instance = new Sub;
expect(instance).toBe(singleton);
instance = new Sub;
expect(instance).toBe(singleton);
class Null extends Foo {
constructor() {
if (false) {
super();
}
return null;
super();
}
}
expect(() => {
new Null();
}).toThrow("this");
"#
);
// regression_2694
// regression_5769
test!(
syntax(),
|t| tr(t),
regression_5769,
r#"
class Point {
getX() {
expect(this.x).toBe(3); // C
}
}
class ColorPoint extends Point {
constructor() {
super();
this.x = 2;
super.x = 3;
expect(this.x).toBe(3); // A
expect(super.x).toBeUndefined(); // B
}
m() {
this.getX();
}
}
const cp = new ColorPoint();
cp.m();
"#
);
// spec_super_function_fallback
test!(
syntax(),
|t| spec_tr(t),
spec_super_function_fallback,
r#"
class Test {
constructor() {
super.hasOwnProperty("test");
}
}
"#
);
// regression_t7537
// regression_3028
test!(
// Module
ignore,
syntax(),
|t| tr(t),
regression_3028,
r#"
class b {
}
class a1 extends b {
constructor() {
super();
this.x = () => this;
}
}
export default class a2 extends b {
constructor() {
super();
this.x = () => this;
}
}
"#
);
// spec_super_illegal_non_constructor_call
// spec_instance_setter
test!(
syntax(),
|t| spec_tr(t),
spec_instance_setter,
r#"
class Test {
set test(val) {
this._test = val;
}
}
"#
);
// spec_nested_object_super_call_in_key
test!(
syntax(),
|t| spec_tr(t),
spec_nested_object_super_call_in_key,
r#"
class Hello {
constructor() {
return {
toString() {
return 'hello';
},
};
}
}
class Outer extends Hello {
constructor() {
const Inner = {
[super()]() {
return 'hello';
},
};
return Inner;
}
}
expect(new Outer().hello()).toBe('hello');
"#
);
// get_set_set_semantics_not_defined_on_parent_not_on_obj
test!(
syntax(),
|t| tr(t),
get_set_set_semantics_not_defined_on_parent_not_on_obj,
r#"
class Base {
}
class Obj extends Base {
set() {
return super.test = 3;
}
}
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBeUndefined();
expect(obj.test).toBe(3);
"#
);
// spec_derived_constructor_no_super_return_falsy
test!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_no_super_return_falsey,
r#"
class Child extends Base {
constructor(){
return false;
}
}
"#
);
// spec_this_not_allowed_before_super_in_derived_classes_5
test!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_5,
r#"
class Foo extends Bar {
constructor() {
Foo[this];
}
}
"#
);
// exec_super_change
// spec_constructor
test!(
syntax(),
|t| spec_tr(t),
spec_constructor,
r#"
class Test {
constructor() {
this.state = "test";
}
}
class Foo extends Bar {
constructor() {
super();
this.state = "test";
}
}
class ConstructorScoping {
constructor(){
let bar;
{
let bar;
}
}
}
"#
);
// spec_preserves_directives
test!(
syntax(),
|t| spec_tr(t),
spec_preserves_directives,
r#"
class MyCtrl {
constructor(a) {
"any directive prologue";
foo;
}
}
class MyCtrl2 {
constructor(a) {
"a";
"b";
foo;
}
}
class MyCtrl3 {
constructor(a) {
"a";
foo;
"b";
}
}
"#
);
// spec_super_reference_before_in_lambda
// spec_derived_constructor_no_super_return_object
test!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_no_super_return_object,
r#"
class Child extends Base {
constructor(){
return {};
}
}
"#
);
// regression_t6750
test!(
// Module
ignore,
syntax(),
|t| tr(t),
regression_t6750,
r#"
export default function() {
return class Select {
query(query) {
}
}
}
"#
);
// spec_instance_method
test!(
syntax(),
|t| spec_tr(t),
spec_instance_method,
r#"
class Test {
test() {
return 5 + 5;
}
}
"#
);
// regression_t2997
test!(
syntax(),
|t| tr(t),
regression_t2997,
r#"
class A {}
class B extends A {
constructor() {
return super();
}
}
"#
);
// spec_constructor_binding_collision
test!(
syntax(),
|t| spec_tr(t),
spec_constructor_binding_collision,
r#"
class Example {
constructor() {
var Example;
}
}
var t = new Example();
"#
);
// spec_super_class_anonymous
test!(
syntax(),
|t| spec_tr(t),
spec_super_class_anonymous,
r#"
class TestEmpty extends (class {}) {
}
class TestConstructorOnly extends (class { constructor() {} }) {
}
class TestMethodOnly extends (class { method() {} }) {
}
class TestConstructorAndMethod extends (class {
constructor() {}
method() {}
}) {
}
class TestMultipleMethods extends (class {
m1() {}
m2() {}
}) {}
"#
);
// spec_method_return_type_annotation
// spec_nested_class_super_call_in_key
test!(
syntax(),
|t| spec_tr(t),
spec_nested_class_super_call_in_key,
r#"
class Hello {
constructor() {
return {
toString() {
return 'hello';
},
};
}
}
class Outer extends Hello {
constructor() {
class Inner {
[super()]() {
return 'hello';
}
}
return new Inner();
}
}
expect(new Outer().hello()).toBe('hello');
"#
);
// extend_builtins_builtin_objects_throw_when_wrapped
// regression_2663
test!(
// Module
ignore,
syntax(),
|t| tr(t),
regression_2663,
r#"
import net from 'net';
import { EventEmitter } from 'events';
import BinarySerializer from './helpers/binary-serializer';
// import ...
export default class Connection extends EventEmitter {
constructor(endpoint, joinKey, joinData, roomId) {
super();
this.isConnected = false;
this.roomId = roomId;
// ...
}
send(message) {
this.sock.write(BinarySerializer.serializeMessage(message));
}
disconnect() {
this.sock.close();
}
}
"#
);
// get_set_set_semantics_setter_defined_on_parent_exec
test_exec!(
syntax(),
|t| tr(t),
get_set_set_semantics_setter_defined_on_parent_exec,
r#"
let value = 1;
class Base {
set test(v) {
value = v;
}
}
class Obj extends Base {
set() {
return super.test = 3;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(value).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBe(2);
expect(obj.test).toBe(2);
"#
);
// regression_5817_exec
test_exec!(
syntax(),
|t| tr(t),
regression_5817_exec,
r#"
// https://github.com/babel/babel/issues/5817
class Parent {}
class Table extends Parent {
constructor() {
super();
this.returnParam = (param) => {
return param;
}
}
}
const table = new Table();
expect(table.returnParam(false)).toBe(false);
"#
);
// exec_class_prototype
// spec_instance_getter
test!(
syntax(),
|t| spec_tr(t),
spec_instance_getter,
r#"
class Test {
get test() {
return 5 + 5;
}
}
"#
);
// spec_this_not_allowed_before_super_in_derived_classes_3
test!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_3,
r#"
class Foo extends Bar {
constructor() {
const fn = () => this;
fn();
super();
}
}
"#
);
// spec_accessing_super_class
test!(
// TODO(kdy1): Unignore this.
ignore,
syntax(),
|t| spec_tr(t),
spec_accessing_super_class,
r#"
class Test extends Foo {
constructor() {
woops.super.test();
super();
super.test();
super(...arguments);
super("test" ...arguments);
super.test(...arguments);
super.test("test" ...arguments);
}
test() {
super.test();
super.test(...arguments);
super.test("test" ...arguments);
}
static foo() {
super.foo();
super.foo(...arguments);
super.foo("test" ...arguments);
}
}
"#
);
// spec_this_not_allowed_before_super_in_derived_classes_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
this.foo = "bar";
super();
}
}
expect(() => new Foo()).toThrow();
"#
);
// spec_nested_object_super_property_in_key_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_nested_object_super_property_in_key_exec,
r#"
class Hello {
toString() {
return 'hello';
}
}
class Outer extends Hello {
constructor() {
super();
const Inner = {
[super.toString()]() {
return 'hello';
},
};
return Inner;
}
}
expect(new Outer().hello()).toBe('hello');
"#
);
// regression_t6712
test!(
syntax(),
|t| tr(t),
regression_t6712,
r#"
class A {
foo() {
const foo = 2;
}
}
"#
);
// get_set_set_semantics_setter_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_set_semantics_setter_defined_on_parent,
r#"
let value = 1;
class Base {
set test(v) {
value = v;
}
}
class Obj extends Base {
set() {
return super.test = 3;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(value).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBe(2);
expect(obj.test).toBe(2);
"#
);
// get_set_call_semantics_not_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_call_semantics_not_defined_on_parent,
r#"
class Base {
}
class Obj extends Base {
call() {
return super.test();
}
test() {
throw new Error("gobbledygook");
}
}
const obj = new Obj();
expect(() => {
obj.call();
// Asser that this throws, but that it's not
// Obj.p.test's error that is thrown
}).toThrowError(TypeError)
"#
);
// spec_derived_constructor_must_call_super_2_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_must_call_super_2_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
if (eval("false")) super();
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// exec_declaration
// spec_nested_object_super_property_in_key
test!(
syntax(),
|t| spec_tr(t),
spec_nested_object_super_property_in_key,
r#"
class Hello {
toString() {
return 'hello';
}
}
class Outer extends Hello {
constructor() {
super();
const Inner = {
[super.toString()]() {
return 'hello';
},
};
return Inner;
}
}
expect(new Outer().hello()).toBe('hello');
"#
);
test!(
syntax(),
|t| tr(t),
nested_this_in_key,
r#"
class Outer extends B {
constructor() {
class Inner {
[this]() {
return 'hello';
}
}
function foo() {
return this;
}
return new Inner();
}
}
"#
);
// get_set_set_semantics_not_defined_on_parent_setter_on_obj_exec
test_exec!(
syntax(),
|t| tr(t),
get_set_set_semantics_not_defined_on_parent_setter_on_obj_exec,
r#"
class Base {
}
let value = 2;
class Obj extends Base {
set test(v) {
value = v;
}
set() {
return super.test = 3;
}
}
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBeUndefined();
expect(value).toBe(2);
expect(obj.test).toBe(3);
"#
);
// exec_expression
// spec_this_not_allowed_before_super_in_derived_classes_2_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_2_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
super(this);
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// spec_super_reference_before_bare_super_inline_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_super_reference_before_bare_super_inline_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
super.foo(super());
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// get_set_call_semantics_setter_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_call_semantics_setter_defined_on_parent,
r#"
class Base {
set test(v) {
throw new Error("gobbledygook");
}
}
class Obj extends Base {
call() {
return super.test();
}
test() {
throw new Error("gobbledygook");
}
}
const obj = new Obj();
expect(() => {
obj.call();
// Assert that this throws, but that it's not
// a gobbledygook error that is thrown
}).toThrowError(TypeError)
"#
);
// spec_super_class
test!(
syntax(),
|t| spec_tr(t),
spec_super_class,
r#"
class Test extends Foo { }
"#
);
// spec_super_call_only_allowed_in_derived_constructor
// spec_nested_object_super_call_in_key_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_nested_object_super_call_in_key_exec,
r#"
class Hello {
constructor() {
return {
toString() {
return 'hello';
},
};
}
}
class Outer extends Hello {
constructor() {
const Inner = {
[super()]() {
return 'hello';
},
};
return Inner;
}
}
expect(new Outer().hello()).toBe('hello');
"#
);
// spec_derived_constructor_must_call_super_2
test!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_must_call_super_2,
r#"
class Foo extends Bar {
constructor() {
if (eval("false")) super();
}
}
"#
);
// spec_derived_constructor_must_call_super_3
test!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_must_call_super_3,
r#"
class Foo extends Bar {
constructor() {
const fn = () => super();
fn();
}
}
"#
);
// spec_this_not_allowed_before_super_in_derived_classes_3_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_this_not_allowed_before_super_in_derived_classes_3_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
const fn = () => this;
fn();
super();
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// get_set_set_semantics_not_defined_on_parent_data_on_obj
test!(
syntax(),
|t| tr(t),
get_set_set_semantics_not_defined_on_parent_data_on_obj,
r#"
class Base {
}
class Obj extends Base {
set() {
return super.test = 3;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBe(2);
expect(obj.test).toBe(3);
"#
);
// get_set_memoized_assign
test!(
syntax(),
|t| tr(t),
get_set_memoized_assign,
r#"
class Base {}
Object.defineProperty(Base.prototype, 0, {
value: 0,
writable: true,
configurable: true,
});
Object.defineProperty(Base.prototype, 1, {
value: 1,
writable: true,
configurable: true,
});
let i = 0;
const proper = {
get prop() {
return i++;
},
};
class Obj extends Base {
assign() {
super[proper.prop] += 1;
}
assign2() {
super[i] += 1;
}
}
const obj = new Obj();
obj.assign();
expect(i).toBe(1);
expect(obj[0]).toBe(1);
expect(obj[1]).toBe(1);
obj.assign2();
expect(i).toBe(1);
expect(obj[0]).toBe(1);
expect(obj[1]).toBe(2);
"#
);
// spec_nested_class_super_property_in_key_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_nested_class_super_property_in_key_exec,
r#"
class Hello {
toString() {
return 'hello';
}
}
class Outer extends Hello {
constructor() {
super();
class Inner {
[super.toString()]() {
return 'hello';
}
}
return new Inner();
}
}
expect(new Outer().hello()).toBe('hello');
"#
);
// spec_relaxed_method_coercion
test!(
syntax(),
|t| spec_tr(t),
spec_relaxed_method_coercion,
r#"
// #1649
class Foo {
[Symbol()]() {}
[Symbol()]() {}
}
"#
);
// spec_derived_constructor_must_call_super_3_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_must_call_super_3_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
const fn = () => super();
fn();
}
}
new Foo();
"#
);
// spec_computed_methods_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_computed_methods_exec,
r#"
const sym = Symbol();
class Foo {
[sym] () {
return 1;
}
}
class Bar extends Foo {
[sym] () {
return super[sym]() + 2;
}
}
let i = new Bar();
expect(i[sym]()).toBe(3);
"#
);
// spec_derived_constructor_must_call_super_4
test!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_must_call_super_4,
r#"
class Foo extends Bar {
constructor() {
const fn = () => super();
}
}
"#
);
// spec_super_class_id_member_expression
test!(
syntax(),
|t| spec_tr(t),
spec_super_class_id_member_expression,
r#"
class BaseController extends Chaplin.Controller {
}
class BaseController2 extends Chaplin.Controller.Another {
}
"#
);
// spec_delay_arrow_function_for_bare_super_derived
test!(
syntax(),
|t| spec_tr(t),
spec_delay_arrow_function_for_bare_super_derived,
r#"
class Foo extends Bar {
constructor() {
super(() => {
this.test;
});
}
}
"#
);
// extend_builtins_overwritten_null
// spec_default_super_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_default_super_exec,
r#"
class Test {
constructor() {
return super.constructor;
}
static test() {
return super.constructor;
}
}
// Instances
expect(Object.getPrototypeOf(Test.prototype)).toBe(Object.prototype);
expect(new Test()).toBe(Object);
// Static
expect(Object.getPrototypeOf(Test)).toBe(Function.prototype);
expect(Test.test()).toBe(Function);
"#
);
// spec_super_reference_before_in_lambda_3_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_super_reference_before_in_lambda_3_exec,
r#"
class Bar {
test() {}
}
class Foo extends Bar {
constructor() {
const t = () => super.test()
super();
t();
}
}
new Foo();
"#
);
// regression
// get_set_get_semantics_not_defined_on_parent
test!(
syntax(),
|t| tr(t),
get_set_get_semantics_not_defined_on_parent,
r#"
class Base {
}
class Obj extends Base {
get() {
return super.test;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.test).toBe(2);
expect(obj.get()).toBeUndefined();
"#
);
// extend_builtins_super_called
// spec_plain_class
test!(
syntax(),
|t| spec_tr(t),
spec_plain_class,
r#"
class Test { }
"#
);
// spec_super_reference_before_bare_super_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_super_reference_before_bare_super_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
super.foo();
super();
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// spec_super_reference_before_in_lambda_2_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_super_reference_before_in_lambda_2_exec,
r#"
class Bar {
test() {}
}
class Foo extends Bar {
constructor() {
const t = () => super.test()
t();
super();
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// spec_derived_constructor_must_call_super_exec
test_exec!(
syntax(),
|t| spec_tr(t),
spec_derived_constructor_must_call_super_exec,
r#"
class Bar {}
class Foo extends Bar {
constructor() {
}
}
expect(() => new Foo()).toThrow("this hasn't been initialised");
"#
);
// exec_return
// spec_export_super_class
test!(
syntax(),
|t| spec_tr(t),
spec_export_super_class,
r#"
export default class extends A {}
"#
);
// extend_builtins_wrap_native_super_exec
test_exec!(
syntax(),
|t| tr(t),
extend_builtins_wrap_native_super_exec,
r#"
// basic sanity check to confirm the external wrapNativeSuper helper works
class Test1 extends Array {
name() {
return 'test1';
}
}
class Test2 extends Array {
name() {
return 'test2';
}
}
var t1 = new Test1();
var t2 = new Test2();
expect(Test1).not.toBe(Test2);
expect(t1).not.toBe(t2);
expect(t1.name()).toBe('test1');
expect(t2.name()).toBe('test2');
expect(t1).toBeInstanceOf(Test1);
expect(t2).toBeInstanceOf(Test2);
expect(t1).toBeInstanceOf(Array);
expect(t2).toBeInstanceOf(Array);
"#
);
// spec_super_reference_in_prop_expression_exec
test_exec!(
// babel also fails on this
ignore,
syntax(),
|t| spec_tr(t),
spec_super_reference_in_prop_exression_exec,
r#"
let called = false;
class A {
method() {
called = true;
}
get methodName() {
return "method";
}
}
class B extends A {
constructor() {
super[super().methodName]()
}
}
new B();
expect(called).toBe(true);
"#
);
// extend_builtins_imported_babel_plugin_transform_builtin_classes
// get_set_set_semantics_getter_defined_on_parent_exec
test_exec!(
syntax(),
|t| tr(t),
get_set_set_semantics_getter_defined_on_parent_exec,
r#"
let called = false;
class Base {
get test() {
called = true;
return 1;
}
};
class Obj extends Base {
set() {
return super.test = 3;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(() => {
obj.set();
}).toThrow();
expect(called).toBe(false);
expect(Base.prototype.test).toBe(1);
expect(Obj.prototype.test).toBe(2);
expect(obj.test).toBe(2);
"#
);
test!(
syntax(),
|t| spec_tr(t),
issue_454_followup,
"if (true){
class Foo extends Bar { }
}"
);
test!(
syntax(),
|t| spec_tr(t),
issue_454_followup_2,
"function broken(x, ...foo) {
if (true) {
class Foo extends Bar { }
return hello(...foo)
}
}"
);
test!(
syntax(),
|_| (
resolver(Mark::new(), Mark::new(), false),
classes(Default::default())
),
duplicate_ident,
r#"
class Foo extends Bar {
constructor() {
var Foo = 123;
console.log(Foo)
}
}
"#
);
// extend_builtins_shadowed
test!(
// Cost is too high while being useless
ignore,
syntax(),
|t| tr(t),
extend_builtins_shadowed,
r#"
class Array {}
class List extends Array {}
"#
);
//// regression_2694
//test!(
// syntax(),
// |_| tr(r#"{
// "plugins": [],
// "presets": ["env"]
//}
//"#),
// regression_2694,
// r#"
//import BaseFoo from './BaseFoo';
//
//export default class SubFoo extends BaseFoo {
// static talk() {
// super.talk();
// console.log('SubFoo.talk');
// }
//}
//
//"#
// r#"
//"use strict";
//
//Object.defineProperty(exports, "__esModule" {
// value: true
//});
//exports["default"] = void 0;
//
//var BaseFoo2 = _interop_require_default(require("./BaseFoo"));
//
//var SubFoo =
// /*#__PURE__*/
//function (BaseFoo) {
// _inherits(SubFoo, BaseFoo);
//
// function SubFoo() {
// _class_call_check(this, SubFoo);
// return _possible_constructor_return(this,
// _get_prototype_of(SubFoo).apply(this, arguments)); }
//
// _create_class(SubFoo, null, [{
// key: "talk"
// value: function talk() {
// _get(_get_prototype_of(SubFoo), "talk" this).call(this);
// console.log('SubFoo.talk');
// }
// }]);
// return SubFoo;
//}(BaseFoo2["default"]);
//
//exports["default"] = SubFoo;
//
//"#
//);
//// regression_t2494
//test!(
// syntax(),
// |_| tr(r#"{
// "plugins": [ "proposal-class-properties"],
// "presets": ["env" "react"]
//}
//"#),
// regression_t2494,
// r#"
//var x = {
// Foo: class extends Foo {}
//};
//
//"#
// r#"
//var x = {
// Foo:
// /*#__PURE__*/
// function (Foo) {
// "use strict";
//
// _inherits(_class, Foo);
//
// function _class() {
// _class_call_check(this, _class);
// return _possible_constructor_return(this,
// _get_prototype_of(_class).apply(this, arguments)); }
//
// return _class;
// }(Foo)
//};
//
//"#
//);
// extend_builtins_imported_babel_plugin_transform_builtin_classes
test_exec!(
syntax(),
|_| (classes(Default::default()), block_scoping(Mark::new())),
extend_builtins_imported_babel_plugin_transform_builtin_classes_exec,
r#"
// Imported from
// https://github.com/WebReflection/babel-plugin-transform-builtin-classes/blob/85efe1374e1c59a8323c7eddd4326f6c93d9f64f/test/test.js
class List extends Array {
constructor(value) {
super().push(value);
}
push(value) {
super.push(value);
return this;
}
}
expect(new List(1)).toBeInstanceOf(List);
expect(new List(2)).toBeInstanceOf(Array);
var l = new List(3);
expect(l).toHaveLength(1);
expect(l[0]).toBe(3);
expect(l.push(4)).toBe(l);
expect(l).toHaveLength(2);
expect(l.join()).toBe('3,4');
class SecondLevel extends List {
method() {
return this;
}
}
expect(new SecondLevel(1)).toBeInstanceOf(SecondLevel);
expect(new SecondLevel(2)).toBeInstanceOf(List);
expect(new SecondLevel(3)).toBeInstanceOf(Array);
var s = new SecondLevel(4);
expect(s).toHaveLength(1);
expect(s[0]).toBe(4);
expect(s.push(5)).toBe(s);
expect(s).toHaveLength(2);
expect(s.join()).toBe('4,5');
expect(s.method()).toBe(s);
"#
);
// get_set_call_semantics_setter_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_call_semantics_setter_defined_on_parent_exec,
r#"
"use strict";
class Base {
set test(v) {
throw new Error("gobbledygook");
}
}
class Obj extends Base {
call() {
return super.test();
}
test() {
throw new Error("gobbledygook");
}
}
const obj = new Obj();
expect(() => {
obj.call();
// Assert that this throws, but that it's not
// a gobbledygook error that is thrown
}).toThrowError(TypeError)
"#
);
// get_set_call_semantics_not_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_call_semantics_not_defined_on_parent_exec,
r#"
"use strict";
class Base {
}
class Obj extends Base {
call() {
return super.test();
}
test() {
throw new Error("gobbledygook");
}
}
const obj = new Obj();
expect(() => {
obj.call();
// Asser that this throws, but that it's not
// Obj.p.test's error that is thrown
}).toThrowError(TypeError)
"#
);
// get_set_set_semantics_not_defined_on_parent_getter_on_obj
test_exec!(
syntax(),
|t| tr(t),
get_set_set_semantics_not_defined_on_parent_getter_on_obj_exec,
r#"
"use strict";
class Base {
}
let called = false;
class Obj extends Base {
get test() {
called = true;
}
set() {
return super.test = 3;
}
}
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(called).toBe(false);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBeUndefined();
expect(obj.test).toBe(3);
"#
);
//// regression_t6712
//test!(
// syntax(),
// |_| tr(r#"{
// "plugins": [ "proposal-class-properties"],
// "presets": ["env" "react"]
//}
//"#),
// regression_t6712,
// r#"
//class A {
// foo() {
// const foo = 2;
// }
//}
//
//"#
// r#"
//var A =
// /*#__PURE__*/
//function () {
// "use strict";
//
// function A() {
// _class_call_check(this, A);
// }
//
// _create_class(A, [{
// key: "foo"
// value: function foo() {
// var foo = 2;
// }
// }]);
// return A;
//}();
//
//"#
//);
// get_set_set_semantics_not_defined_on_parent_data_on_obj
test_exec!(
syntax(),
|t| tr(t),
get_set_set_semantics_not_defined_on_parent_data_on_obj_exec,
r#"
"use strict";
class Base {
}
class Obj extends Base {
set() {
return super.test = 3;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBe(2);
expect(obj.test).toBe(3);
"#
);
//// regression_2663
//test!(
// syntax(),
// |_| tr(r#"{
// "plugins": [ "proposal-class-properties"],
// "presets": ["env" "react"]
//}
//"#),
// regression_2663,
// r#"
//import net from 'net';
//import { EventEmitter } from 'events';
//import BinarySerializer from './helpers/binary-serializer';
//// import ...
//
//export default class Connection extends EventEmitter {
// constructor(endpoint, joinKey, joinData, roomId) {
// super();
//
// this.isConnected = false;
// this.roomId = roomId;
//
// // ...
// }
//
// send(message) {
// this.sock.write(BinarySerializer.serializeMessage(message));
// }
//
// disconnect() {
// this.sock.close();
// }
//}
//
//"#
// r#"
//"use strict";
//
//Object.defineProperty(exports, "__esModule" {
// value: true
//});
//exports["default"] = void 0;
//
//var _net = _interop_require_default(require("net"));
//
//var _events = require("events");
//
//var _binarySerializer =
// _interop_require_default(require("./helpers/binary-serializer"));
//
//// import ...
//var Connection =
// /*#__PURE__*/
//function (_EventEmitter) {
// _inherits(Connection, _EventEmitter);
//
// function Connection(endpoint, joinKey, joinData, roomId) {
// var _this;
//
// _class_call_check(this, Connection);
// _this = _possible_constructor_return(this,
// _get_prototype_of(Connection).call(this)); _this.isConnected = false;
// _this.roomId = roomId; // ...
//
// return _this;
// }
//
// _create_class(Connection, [{
// key: "send"
// value: function send(message) {
// this.sock.write(_binarySerializer["default"].serializeMessage(message));
// }
// }, {
// key: "disconnect"
// value: function disconnect() {
// this.sock.close();
// }
// }]);
// return Connection;
//}(_events.EventEmitter);
//
//exports["default"] = Connection;
//
//"#
//);
// extend_builtins_spec
test_exec!(
syntax(),
|_| (classes(Default::default()), block_scoping(Mark::new())),
extend_builtins_spec_exec,
r#"
class List extends Array {}
expect(new List).toBeInstanceOf(List);
expect(new List).toBeInstanceOf(Array);
"#
);
// get_set_call_semantics_data_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_call_semantics_data_defined_on_parent_exec,
r#"
"use strict";
class Base {
test(...args) {
expect(this).toBe(obj);
expect(args).toEqual([1, 2, 3]);
return 1;
}
}
class Obj extends Base {
call() {
super.test(1, 2, 3);
super.test(1, ...[2, 3]);
super.test(...[1, 2, 3]);
return super.test(...arguments);
}
test() {
throw new Error("called");
}
}
const obj = new Obj();
expect(obj.call(1, 2, 3)).toBe(1);
"#
);
// get_set_memoized_assign
test_exec!(
syntax(),
|t| tr(t),
get_set_memoized_assign_exec,
r#"
"use strict";
class Base {}
Object.defineProperty(Base.prototype, 0, {
value: 0,
writable: true,
configurable: true,
});
Object.defineProperty(Base.prototype, 1, {
value: 1,
writable: true,
configurable: true,
});
let i = 0;
const proper = {
get prop() {
return i++;
},
};
class Obj extends Base {
assign() {
super[proper.prop] += 1;
}
assign2() {
super[i] += 1;
}
}
const obj = new Obj();
obj.assign();
expect(i).toBe(1);
expect(obj[0]).toBe(1);
expect(obj[1]).toBe(1);
obj.assign2();
expect(i).toBe(1);
expect(obj[0]).toBe(1);
expect(obj[1]).toBe(2);
"#
);
// get_set_get_semantics_setter_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_get_semantics_setter_defined_on_parent_exec,
r#"
"use strict";
class Base {
set test(v) {
throw new Error("called");
}
}
class Obj extends Base {
get() {
return super.test;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.test).toBe(2);
expect(obj.get()).toBeUndefined();
"#
);
// regression_t7010
test!(
// TODO: Unignore this
ignore,
syntax(),
|t| (tr(t), block_scoping(Mark::new())),
regression_t7010,
r#"
class Foo {
constructor(val){
this._val = val;
}
foo2(){
return foo2(this._val);
}
}
"#
);
//// regression_2941
//test!(
// syntax(),
// |_| tr(r#"{
// "plugins": [ "proposal-class-properties"],
// "presets": ["env" "react"]
//}
//"#),
// regression_2941,
// r#"
//export default class {}
//
//"#
// r#"
//"use strict";
//
//Object.defineProperty(exports, "__esModule" {
// value: true
//});
//exports["default"] = void 0;
//
//var _default = function _default() {
// _class_call_check(this, _default);
//};
//
//exports["default"] = _default;
//
//"#
//);
// get_set_call_semantics_getter_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_call_semantics_getter_defined_on_parent_exec,
r#"
"use strict";
class Base {
get test() {
expect(this).toBe(obj);
return function(...args) {
expect(this).toBe(obj);
expect(args).toEqual([1, 2, 3]);
return 1;
};
}
}
class Obj extends Base {
call() {
super.test(1, 2, 3);
super.test(1, ...[2, 3]);
super.test(...[1, 2, 3]);
return super.test(...arguments);
}
test() {
throw new Error("called");
}
}
const obj = new Obj();
expect(obj.call(1, 2, 3)).toBe(1);
"#
);
// get_set_set_semantics_data_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_set_semantics_data_defined_on_parent_exec,
r#"
"use strict";
class Base {
}
Object.defineProperty(Base.prototype, 'test', {
value: 1,
writable: true,
configurable: true,
});
class Obj extends Base {
set() {
return super.test = 3;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBe(1);
expect(Obj.prototype.test).toBe(2);
expect(obj.test).toBe(3);
"#
);
// get_set_get_semantics_getter_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_get_semantics_getter_defined_on_parent_exec,
r#"
"use strict";
class Base {
get test() {
expect(this).toBe(obj);
return 1;
}
}
class Obj extends Base {
get() {
return super.test;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.test).toBe(2);
expect(obj.get()).toBe(1);
"#
);
// get_set_memoized_update
test_exec!(
syntax(),
|t| tr(t),
get_set_memoized_update_exec,
r#"
"use strict";
class Base {}
Object.defineProperty(Base.prototype, 0, {
value: 0,
writable: true,
configurable: true,
});
Object.defineProperty(Base.prototype, 1, {
value: 1,
writable: true,
configurable: true,
});
let i = 0;
const proper = {
get prop() {
return i++;
},
};
class Obj extends Base {
update() {
super[proper.prop]++;
}
update2() {
super[i]++;
}
}
const obj = new Obj();
obj.update();
expect(i).toBe(1);
expect(obj[0]).toBe(1);
expect(obj[1]).toBe(1);
obj.update2();
expect(i).toBe(1);
expect(obj[0]).toBe(1);
expect(obj[1]).toBe(2);
"#
);
// get_set_get_semantics_not_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_get_semantics_not_defined_on_parent_exec,
r#"
"use strict";
class Base {
}
class Obj extends Base {
get() {
return super.test;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.test).toBe(2);
expect(obj.get()).toBeUndefined();
"#
);
// get_set_set_semantics_not_defined_on_parent_not_on_obj
test_exec!(
syntax(),
|t| tr(t),
get_set_set_semantics_not_defined_on_parent_not_on_obj_exec,
r#"
"use strict";
class Base {
}
class Obj extends Base {
set() {
return super.test = 3;
}
}
const obj = new Obj();
expect(obj.set()).toBe(3);
expect(Base.prototype.test).toBeUndefined();
expect(Obj.prototype.test).toBeUndefined();
expect(obj.test).toBe(3);
"#
);
// extend_builtins_builtin_objects_throw_when_wrapped
test_exec!(
syntax(),
|_| (classes(Default::default()), block_scoping(Mark::new())),
extend_builtins_builtin_objects_throw_when_wrapped_exec,
r#"
// JSON is wrapped because it starts with an uppercase letter, but it
// should not be possible to extend it anyway.
expect(() => class BetterJSON extends JSON {}).toThrow();
"#
);
// get_set_get_semantics_data_defined_on_parent
test_exec!(
syntax(),
|t| tr(t),
get_set_get_semantics_data_defined_on_parent_exec,
r#"
"use strict";
class Base {
}
Object.defineProperty(Base.prototype, 'test', {
value: 1,
writable: true,
configurable: true,
});
class Obj extends Base {
get() {
return super.test;
}
}
Object.defineProperty(Obj.prototype, 'test', {
value: 2,
writable: true,
configurable: true,
});
const obj = new Obj();
expect(obj.test).toBe(2);
expect(obj.get()).toBe(1);
"#
);
// extend_builtins_overwritten_null
test_exec!(
// Just don't do this.
ignore,
syntax(),
|_| (classes(Default::default()), block_scoping(Mark::new())),
extend_builtins_overwritten_null_exec,
r#"
var env = {
Array: null,
};
// We need to use "with" to avoid leaking the modified Array to other tests.
with (env) {
class List extends Array {}
expect(List.prototype.__proto__).toBeUndefined();
}
"#
);
// extend_builtins_super_called
test_exec!(
// Just don't do this. With is evil.
ignore,
syntax(),
|_| (classes(Default::default()), block_scoping(Mark::new())),
extend_builtins_super_called_exec,
r#"
var called = false;
var env = {
Array: function Array() {
called = true;
}
};
// We need to use "with" to avoid leaking the modified Array to other tests.
with (env) {
class List extends Array {};
new List();
expect(called).toBe(true);
}
"#
);
test_exec!(
syntax(),
|_| classes(Default::default()),
issue_846,
r#"
class SomeClass {
someMethod() {
return 1;
}
}
class OtherClass extends SomeClass {
anotherMethod() {
expect(super.someMethod()).toBe(1);
return 2;
}
}
const obj = new OtherClass();
expect(obj.anotherMethod()).toBe(2);
"#
);
test!(
syntax(),
|_| classes(Default::default()),
issue_1490_1,
"
class ColouredCanvasElement extends CanvasElement {
createFacets(hidden) {
hidden = super.createFacets(hidden);
}
}
"
);
test!(
syntax(),
|_| classes(Default::default()),
issue_1490_2,
"
class ColouredCanvasElement extends CanvasElement {
createFacets(hidden) {
super.createFacets(hidden);
}
}
"
);
test!(
syntax(),
|_| classes(Default::default()),
super_binding,
"
class Foo {}
class Test extends Foo {
foo() {
console.log(Foo)
}
}
"
);
test_exec!(
syntax(),
|_| classes(Default::default()),
super_binding_exec,
"
class Foo {}
class Test extends Foo {
foo() {
return 3;
}
}
Foo = 3;
expect(new Test().foo()).toBe(3);
"
);
test!(
syntax(),
|_| classes(Default::default()),
issue_1617_1,
"
class A extends B {
foo() {
super.foo(), bar();
}
}
"
);
test!(
syntax(),
|_| classes(Default::default()),
issue_1617_2,
"
class A extends B {
foo() {
super.foo();
}
}
"
);
test!(
syntax(),
|_| classes(Default::default()),
issue_1660_1,
"
class A {
}
"
);
test!(
syntax(),
|_| classes(Default::default()),
constructor_super_update,
"
class A extends B {
constructor() {
super.foo ++;
super.bar += 123;
super[baz] --;
super[quz] -= 456;
}
}
"
);
test!(
syntax(),
|_| classes(Default::default()),
prefix_super_update,
"
class A extends B {
foo() {
--super[baz];
}
}
"
);
test!(
syntax(),
|_| classes(Default::default()),
issue_1660_2,
"
const foo = class {run(){}};
"
);
test!(
syntax(),
|_| classes(Default::default()),
issue_1660_3,
"
console.log(class { run() { } });
"
);
test!(
syntax(),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
es2022::es2022(Default::default(), unresolved_mark),
es2018::es2018(Default::default()),
es2017::es2017(Default::default(), unresolved_mark),
es2016::es2016(),
es2015::es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
issue_1660_4,
"
console.log(class { run() { } });
"
);
test!(
syntax(),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
es2015::es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
issue_1660_5,
"
console.log(class { run() { } });
"
);
test!(
syntax(),
|t| tr(t),
issue_1838,
r#"
class Foo {
let() {}
}
"#
);
test!(
syntax(),
|t| tr(t),
issue_1799_1,
"
export default function Foo() {
return call(async (e) => { await doSomething(); })
}
"
);
test!(
syntax(),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
es2015::es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
issue_1959_1,
"
class Extended extends Base {
getNext() {
return super.getNext(114514) + 114514
}
}
"
);
test!(
syntax(),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
es2015::es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
issue_1959_2,
"
class Extended extends Base {
getNext() {
return super.getNext(114514)
}
}
"
);
#[testing::fixture("tests/classes/**/exec.js")]
fn exec(input: PathBuf) {
let src = read_to_string(input).unwrap();
compare_stdout(
Default::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
)
},
&src,
);
}
#[testing::fixture("tests/classes/**/input.js")]
fn fixture(input: PathBuf) {
let output = input.parent().unwrap().join("output.js");
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
)
},
&input,
&output,
Default::default(),
);
}
test!(
syntax(),
|_| classes(Config {
constant_super: true,
..Default::default()
}),
constant_super_class,
r#"
class Test extends Foo {
constructor() {
woops.super.test();
super();
super.test();
super(...arguments);
super("test", ...arguments);
super.test(...arguments);
super.test("test", ...arguments);
}
}
"#
);
test!(
syntax(),
|_| classes(Config {
constant_super: true,
..Default::default()
}),
constant_super_property,
r#"
class Test extends Foo {
constructor() {
super();
super.test;
super.test.whatever;
}
}
"#
);
test!(
syntax(),
|_| classes(Config {
constant_super: true,
..Default::default()
}),
constant_super_call,
r#"
class Test extends Foo {
constructor() {
super();
super.test.whatever();
super.test();
}
static test() {
return super.wow();
}
}
"#
);
test!(
syntax(),
|_| classes(Config {
constant_super: true,
..Default::default()
}),
constant_super_default,
r#"
class Test {
constructor() {
super.hasOwnProperty("test");
return super.constructor;
}
static test() {
return super.constructor;
}
}
"#
);
test!(
syntax(),
|_| classes(Config {
constant_super: true,
..Default::default()
}),
constant_super_update,
r#"
class A extends B {
constructor() {
super.foo ++;
super.bar += 123;
super[baz] --;
super[quz] -= 456
}
}
"#
);
test!(
syntax(),
|_| classes(Config {
no_class_calls: true,
..Default::default()
}),
no_class_call,
"class A {}"
);
test!(
syntax(),
|_| classes(Config {
no_class_calls: true,
..Default::default()
}),
no_class_call_constructor,
r#"
class A {
constructor() {
console.log('a');
}
}
class B {
b() {
console.log('b');
}
}
"#
);
test!(
syntax(),
|_| classes(Config {
no_class_calls: true,
..Default::default()
}),
no_class_call_super,
r#"
class B {}
class A extends B {
constructor(track) {
if (track !== undefined) super(track);
else super();
}
}
"#
);
test!(
syntax(),
|_| classes(Config {
set_class_methods: true,
..Default::default()
}),
set_method_literal_key,
r#"
class Foo {
"bar"() {
}
}
"#
);
test!(
syntax(),
|_| classes(Config {
set_class_methods: true,
..Default::default()
}),
set_method_static,
r#"
class Test {
a() {}
static b() {}
c() {}
}
"#
);
test!(
syntax(),
|_| classes(Config {
set_class_methods: true,
..Default::default()
}),
set_method_getter_setter,
r#"
class Test extends Foo {
"foo"() {}
get foo() {}
set foo(a) {}
}
"#
);
test!(
syntax(),
|_| classes(Config {
super_is_callable_constructor: true,
..Default::default()
}),
super_callable,
r#"
class BaseController extends Chaplin.Controller { }
class BaseController2 extends Chaplin.Controller.Another { }
"#
);
test!(
syntax(),
|_| classes(Config {
super_is_callable_constructor: true,
..Default::default()
}),
super_callable_super,
r#"class Test extends Foo { }"#
);
test!(
syntax(),
|_| classes(Config {
super_is_callable_constructor: true,
..Default::default()
}),
issue_3943,
r#"
class Thing extends B {
constructor(n) {
super()
this.name = n
}
}
"#
);
test!(
syntax(),
|_| (classes(Default::default()), block_scoping(Mark::new())),
issue_5102,
r#"
let C = class {}
D = class {}
C ||= class /* C */ {};
D ??= class /* D */ {};
"#
);
test_exec!(
syntax(),
|_| classes(Config {
constant_super: true,
..Default::default()
}),
issue_5936,
"
class Superclass {
doStuff() {
}
}
class Subclass extends Superclass {
doStuff() {
console.log('hola');
super.doStuff();
}
}
expect(() => new Subclass().doStuff()).not.toThrowError()
"
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_computed_props.rs | Rust | #![allow(clippy::unit_arg)]
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_compat::es2015::computed_props::{computed_properties, Config};
use swc_ecma_transforms_testing::{test, test_exec};
fn syntax() -> Syntax {
::swc_ecma_parser::Syntax::default()
}
fn tr(_: ()) -> impl Pass {
computed_properties(Default::default())
}
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
issue_210,
"
const b = {[a]: 1}
export const c = {[a]: 1}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
big_int,
"
const b = {1n: 1, [x]: 'x', 2n: 2}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
accessors,
r#"var obj = {
get [foobar]() {
return "foobar";
},
set [foobar](x) {
console.log(x);
},
get test() {
return "regular getter after computed property";
},
set "test"(x) {
console.log(x);
}
};
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(()),
issue_2680,
r#"
const obj = {
get [1]() {}
};
"#
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|_| tr(()),
issue_2680_2,
r#"
let a = "outside";
const obj = {
get [{
get [a]() {
let a = "inside";
return a;
},
}.outside]() {
let a = "middle";
return a;
},
};
expect(obj.inside).toBe("middle");
"#
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|_| tr(()),
issue_2680_3,
r#"
const obj = {
foo() {
const obj2 = {
get [1]() {
return 42;
},
};
return obj2;
},
};
expect(obj.foo()[1]).toBe(42);
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(()),
issue_2680_4,
r#"
const obj = {
foo() {
const obj2 = {
get [1]() {
return 42;
},
};
return obj2;
},
};
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
argument,
r#"foo({
[bar]: "foobar"
});"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
assignment,
r#"foo = {
[bar]: "foobar"
};"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
method,
r#"var obj = {
[foobar]() {
return "foobar";
},
test() {
return "regular method after computed property";
}
};"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
mixed,
r#"var obj = {
["x" + foo]: "heh",
["y" + bar]: "noo",
foo: "foo",
bar: "bar",
};"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
multiple,
r#"var obj = {
["x" + foo]: "heh",
["y" + bar]: "noo"
};"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
single,
r#"var obj = {
["x" + foo]: "heh"
};"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
symbol,
r#"var k = Symbol();
var foo = {
[Symbol.iterator]: "foobar",
get [k]() {
return k;
}
};
"#
);
test_exec!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
symbol_exec,
r#"
var k = Symbol();
var foo = {
[Symbol.iterator]: "foobar",
get [k]() {
return k;
}
};
expect(foo[Symbol.iterator]).toBe("foobar")
expect(foo[k]).toBe(k)"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
this,
r#"var obj = {
["x" + foo.bar]: "heh",
};"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
issue_315_1,
"
({
foo: {
bar: null,
[baz]: null
},
[bon]: {
flab: null
}
});
export function corge() {}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
issue_315_2,
"
export function corge() {}
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
issue_315_3,
"
export function corge() {}
({
foo: {
bar: null,
[baz]: null
},
[bon]: {
flab: null
}
});
"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| computed_properties(Default::default()),
issue_315_4,
"
export class Foo {}
({
foo: {
bar: null,
[baz]: null
},
[bon]: {
flab: null
}
});
"
);
// spec_mixed
test!(
syntax(),
|_| tr(Default::default()),
spec_mixed,
r#"
var obj = {
["x" + foo]: "heh",
["y" + bar]: "noo",
foo: "foo",
bar: "bar",
};
"#
);
// spec_single
test!(
syntax(),
|_| tr(Default::default()),
spec_single,
r#"
var obj = {
["x" + foo]: "heh"
};
"#
);
// spec
// regression_7144
test!(
syntax(),
|_| tr(Default::default()),
regression_7144,
r#"
export default {
[a]: b,
[c]: d
};
"#
);
// spec_multiple
test!(
syntax(),
|_| tr(Default::default()),
spec_multiple,
r#"
var obj = {
["x" + foo]: "heh",
["y" + bar]: "noo",
};
"#
);
// spec_this
test!(
syntax(),
|_| tr(Default::default()),
spec_this,
r#"
var obj = {
["x" + foo.bar]: "heh"
};
"#
);
// spec_method
test!(
syntax(),
|_| tr(Default::default()),
spec_method,
r#"
var obj = {
[foobar]() {
return "foobar";
},
test() {
return "regular method after computed property";
}
};
"#
);
// spec_assignment
test!(
syntax(),
|_| tr(Default::default()),
spec_assignment,
r#"
foo = {
[bar]: "foobar"
};
"#
);
// spec_argument
test!(
syntax(),
|_| tr(Default::default()),
spec_argument,
r#"
foo({
[bar]: "foobar"
});
"#
);
// spec_two
test!(
syntax(),
|_| tr(Default::default()),
spec_two,
r#"
var obj = {
first: "first",
["second"]: "second"
};
"#
);
// spec_variable
test!(
syntax(),
|_| tr(Default::default()),
spec_variable,
r#"
var foo = {
[bar]: "foobar"
};
"#
);
// spec_symbol_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
spec_symbol_exec,
r#"
var k = Symbol();
var foo = {
[Symbol.iterator]: "foobar",
get [k]() {
return k;
}
};
expect(foo[Symbol.iterator]).toBe("foobar")
expect(foo[k]).toBe(k)
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_assignment,
r#"
foo = {
[bar]: "foobar"
};
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_argument,
r#"
foo({
[bar]: "foobar"
});
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_coerce,
r#"
var obj = {
foo: "bar",
[bar]: "foo"
};
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_method,
r#"
var obj = {
[foobar]() {
return "foobar";
},
test() {
return "regular method after computed property";
}
};
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_mixed,
r#"
var obj = {
["x" + foo]: "heh",
["y" + bar]: "noo",
foo: "foo",
bar: "bar",
};
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_multiple,
r#"
var obj = {
["x" + foo]: "heh",
["y" + bar]: "noo",
};
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_single,
r#"
var obj = {
["x" + foo]: "heh"
};
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_this,
r#"
var obj = {
["x" + foo.bar]: "heh"
};
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_two,
r#"
var obj = {
first: "first",
[second]: "second"
}
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_variable,
r#"
var foo = {
[bar]: "foobar",
};
"#
);
test!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_str_lit,
r#"
var foo = {
["213"]: "foobar",
};
"#
);
test_exec!(
syntax(),
|_| computed_properties(Config { loose: true }),
loose_symbol,
r#"
var k = Symbol();
var foo = {
[Symbol.iterator]: "foobar",
get [k]() {
return k;
}
};
expect(foo[Symbol.iterator]).toBe("foobar")
expect(foo[k]).toBe(k)
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_destructuring.rs | Rust | use std::path::PathBuf;
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015,
es2015::{
block_scoping,
destructuring::{destructuring, Config},
parameters, spread,
},
es2018::object_rest_spread,
};
use swc_ecma_transforms_testing::{test, test_exec, test_fixture};
fn syntax() -> Syntax {
Default::default()
}
fn tr() -> impl Pass {
(
resolver(Mark::new(), Mark::new(), false),
destructuring(Config { loose: true }),
)
}
test!(
syntax(),
|_| tr(),
issue_2819,
r#"const [first, , third] = ["red", "yellow", "green"]"#
);
test!(
syntax(),
|_| tr(),
issue_2821,
r#"const [x, y, ...z] = [1];"#
);
test!(
syntax(),
|_| destructuring(Config { loose: false }),
need_to_array,
r#"const [x, y, ...z] = o;"#
);
test!(
syntax(),
|_| destructuring(Config { loose: true }),
need_to_array_loose,
r#"const [x, y, ...z] = o;"#
);
test!(
syntax(),
|_| destructuring(Config { loose: false }),
issue_2841,
r#"function foo(a,b)
{
[a,b,...restParam] = arguments;
}"#
);
test!(
syntax(),
|_| destructuring(Config { loose: true }),
issue_2841_loose,
r#"function foo(a,b)
{
[a,b,...restParam] = arguments;
}"#
);
test!(
syntax(),
|_| tr(),
issue_169,
"export class Foo {
func(a, b = Date.now()) {
return {a};
}
}"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
issue_1948,
"
const fn2 = (arg1, {opt1, opt2}, arg2, {opt3, opt4}, ...arg3) => {
console.log(arg1, opt1, opt2, arg2, opt3, opt4, arg3);
};
function fn3(arg1, {opt1, opt2}, arg2, {opt3, opt4}, ...arg3) {
console.log(arg1, opt1, opt2, arg2, opt3, opt4, arg3);
};
class cls {
fn4(arg1, {opt1, opt2}, arg2, {opt3, opt4}, ...arg3) {
console.log(arg1, opt1, opt2, arg2, opt3, opt4, arg3);
}
fn5(arg1, arg2) {
console.log(arg1, arg2);
}
}"
);
test!(syntax(), |_| tr(), issue_260_01, "[code = 1] = []");
test!(
syntax(),
|_| tr(),
array_pat_assign_prop_binding,
"[code = 1] = [1]"
);
test!(
syntax(),
|_| tr(),
array_pat_assign_prop_binding_2,
"[foo = 1, bar = 2] = [3];"
);
test!(
syntax(),
|_| tr(),
array_pat_assign_prop_binding_3,
"[foo = 1, bar = 2] = [3, 4];"
);
test!(
syntax(),
|_| tr(),
array_pat_assign_prop_binding_4,
"const [foo = 1] = [2];"
);
test!(
syntax(),
|_| tr(),
array_pat_assign_prop_binding_5,
"const [foo = 1, bar] = [2, 3];"
);
test!(
syntax(),
|_| tr(),
array_pat_assign_prop_binding_6,
"const [foo = 1] = [];"
);
test!(
syntax(),
|_| tr(),
array_pat_assign_prop_binding_7,
"const [foo = 1] = [1, 2];"
);
test!(
syntax(),
|_| tr(),
issue_260_02,
"[code = 1, ...rest] = [];"
);
test!(
syntax(),
|_| tr(),
object_pat_assign_prop,
"({code = 1} = {})"
);
test!(
syntax(),
|_| tr(),
object_pat_assign_prop_2,
"const {code = 1} = {}"
);
test!(
syntax(),
|_| tr(),
object_pat_assign_prop_binding,
"({foo: bar = 1} = {})"
);
test!(
syntax(),
|_| tr(),
object_pat_assign_prop_binding_2,
"const {foo: bar = 1} = {}"
);
test_exec!(
syntax(),
|_| tr(),
object_pat_assign_prop_binding_3,
r#"
let foo = 1;
let bar = 2;
let x;
let y;
({ [++foo]: x = "c", [++bar]: y = "d" } = { 2: "a" });
expect(foo).toBe(2);
expect(bar).toBe(3);
expect(x).toBe("a");
expect(y).toBe("d");
"#
);
test!(
syntax(),
|_| tr(),
object_pat_assign_prop_binding_isseu_2850,
"const obj = { foo = 123, bar: x = 123 } = { foo: 24, bar: 45 };"
);
test_exec!(
syntax(),
|_| tr(),
object_pat_assign_prop_binding_isseu_2850_exec,
r#"
const obj = { foo = 123, bar: x = 123 } = { foo: 24, bar: 45 };
expect(obj).toEqual({ foo: 24, bar: 45 });
expect(foo).toBe(24);
expect(x).toBe(45);
"#
);
test!(syntax(), |_| tr(), obj_assign_pat, r#"let { a = 1 } = foo"#);
test!(
syntax(),
|_| tr(),
obj_assign_expr,
r#"let a;
[{ a = 1 }] = foo"#
);
test!(
syntax(),
|_| tr(),
array1,
r#"var [a, [b], [c]] = ["hello", [" ", "junk"], ["world"]];"#
);
test!(
syntax(),
|_| tr(),
array2,
r#"[a, [b], [c]] = ["hello", [" ", "junk"], ["world"]];"#
);
test!(
syntax(),
|_| tr(),
assign_expr_completion_record,
r#"var x, y;
[x, y] = [1, 2];"#
);
test!(
syntax(),
|_| tr(),
assign_expr_pat,
r#"var z = {};
var { x: { y } = {} } = z;"#
);
test!(
syntax(),
|_| tr(),
assign_expr,
r#"console.log([x] = [123]);"#
);
test_exec!(
syntax(),
|_| destructuring(Config { loose: true }),
chained,
r#"var a, b, c, d;
({ a, b } = ({ c, d } = { a: 1, b: 2, c: 3, d: 4}));
expect(a).toBe(1);
expect(b).toBe(2);
expect(c).toBe(3);
expect(d).toBe(4);"#
);
test!(
syntax(),
|_| tr(),
empty,
r#"var [, a, [b], [c], d] = ["foo", "hello", [" ", "junk"], ["world"]];"#
);
test!(
ignore,
syntax(),
|_| tr(),
es7_object_rest_builtins,
r#"var z = {};
var { ...x } = z;
var { x, ...y } = z;
var { [x]: x, ...y } = z;
(function({ x, ...y }) { });
({ x, y, ...z } = o);"#
);
test!(
ignore,
syntax(),
|_| tr(),
es7_object_rest,
r#"var z = {};
var { ...x } = z;
var { x, ...y } = z;
var { [x]: x, ...y } = z;
(function({ x, ...y }) { });
({ x, y, ...z } = o);"#
);
test!(
syntax(),
|_| tr(),
export_variable_issue_2858_1,
r#"export const { a: a2, b: b2 } = { a: 1, b: 2 };"#
);
test!(
syntax(),
|_| tr(),
export_variable_issue_2858_2,
r#"export const { a: b } = { a: 1 }"#
);
test!(
syntax(),
|_| tr(),
export_variable_issue_2858_3,
r#"
export const {
a: a1,
b: b1,
b: { c: c1 },
} = { a: 1, b: { c: 1 } };
"#
);
test!(
ignore,
syntax(),
|_| tr(),
export_variable,
r#"export let {a, b, c: {d, e: {f = 4}}} = {};"#
);
test!(
syntax(),
|_| tr(),
for_in,
r#"for (var [name, value] in obj) {
print("Name: " + name + " Value: " + value);
}"#
);
test!(
syntax(),
|_| tr(),
for_let,
r#"for (let [ i, n ] = range; ; ) {}"#
);
test!(
syntax(),
|_| tr(),
for_of,
r#"for (var [ name, before, after ] of test.expectation.registers) {
}"#
);
test_exec!(
ignore,
syntax(),
|_| destructuring(Config { loose: true }),
fn_key_with_obj_rest_spread,
r#"const { [(() => 1)()]: a, ...rest } = { 1: "a" };
expect(a).toBe("a");
expect(rest).toEqual({});"#
);
test!(
syntax(),
|_| tr(),
babel_issue_3081,
r#"let list = [1, 2, 3, 4];
for (let i = 0, { length } = list; i < length; i++) {
list[i];
}"#
);
test_exec!(
syntax(),
|_| destructuring(Config { loose: true }),
babel_issue_5090,
r#"const assign = function([...arr], index, value) {
arr[index] = value;
return arr;
}
const arr = [1, 2, 3];
assign(arr, 1, 42);
expect(arr).toEqual([1, 2, 3]);"#
);
test!(
syntax(),
|_| tr(),
babel_issue_5628,
r#"
(function () {
let q;
let w;
let e;
if (true) [q, w, e] = [1, 2, 3].map(()=>123);
})();"#
);
test!(
syntax(),
|_| tr(),
babel_issue_5744,
r#"if (true) [a, b] = [b, a];"#
);
test!(
ignore,
syntax(),
|_| tr(),
babel_issue_6373,
r#"import { NestedObjects } from "./some-module"
const { Foo, Bar } = NestedObjects"#
);
test!(
syntax(),
|_| tr(),
known_array,
r#"var z = [];
var [x, ...y] = z;"#
);
test!(
syntax(),
|_| tr(),
member_expr,
r#"[foo.foo, foo.bar] = [1, 2];"#
);
test!(
syntax(),
|_| tr(),
multiple,
r#"var coords = [1, 2];
var { x, y } = coords,
foo = "bar";"#
);
test_exec!(
ignore,
syntax(),
|_| destructuring(Config { loose: true }),
number_key_with_object_spread,
r#"const foo = {
1: "a"
2: "b"
3: "c"
};
const { [1]: bar, ...rest } = foo;
expect(bar).toBe("a");
expect(rest).toEqual({ 2: "b" 3: "c" });"#
);
test_exec!(
ignore,
syntax(),
|_| destructuring(Config { loose: true }),
spread_generator,
r#"function* f() {
for (var i = 0; i < 3; i++) {
yield i;
}
}
var [...xs] = f();
expect(xs).toEqual([0, 1, 2]);"#
);
test!(
syntax(),
|_| tr(),
spread_test,
r#"function isSorted([x, y, ...wow]) {
if (!zs.length) return true
if (y > x) return isSorted(zs)
return false
}"#
);
test!(
syntax(),
|_| tr(),
issue_311,
"const Foo = 'foo';
const bar = {
[Foo]: {
qux: 'baz'
}
};
const {
[Foo]: {
qux
}
} = bar;"
);
test!(
syntax(),
|_| tr(),
issue_317,
"export const [
A,
B,
C
] = [1,2,3];
export const [
E,
D,
F
] = [4,5,6];"
);
test!(
syntax(),
|_| tr(),
issue_336,
"const { 'foo-bar': fooBar } = baz;"
);
test!(
syntax(),
|_| tr(),
issue_404_1,
"function foo(bar) {
const { foo } = bar;
return foo;
}"
);
test!(
syntax(),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
issue_404_2,
"function foo(bar) {
const { foo } = bar;
return foo;
}"
);
test!(
syntax(),
|_| tr(),
issue_404_3,
"function foo(bar) {
var { foo: foo1 } = bar;
return foo1;
}"
);
// destructuring_function_key_with_object_rest_spread
test_exec!(
syntax(),
|_| (
object_rest_spread(Default::default()),
destructuring(Default::default())
),
destructuring_function_key_with_object_rest_spread_exec,
r#"
const { [(() => 1)()]: a, ...rest } = { 1: "a" };
expect(a).toBe("a");
expect(rest).toEqual({});
"#
);
// regression_8528
test!(
syntax(),
|_| destructuring(Default::default()),
regression_8528,
r#"
function isBetween(x, a, b) {
if (a > b) [a, b] = [b, a];
return x > a && x < b;
}
"#
);
// destructuring_for_of
test!(
syntax(),
|_| (
spread(Default::default()),
destructuring(Default::default()),
block_scoping(Mark::new()),
object_rest_spread(Default::default()),
),
destructuring_for_of,
r#"
for (var [ name, before, after ] of test.expectation.registers) {
}
for ([ name, before, after ] of test.expectation.registers) {
}
"#
);
// destructuring_object_basic
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_object_basic,
r#"
var coords = [1, 2];
var { x, y } = coords;
"#
);
// destructuring_assignment_arrow_function_block
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_assignment_arrow_function_block,
r#"
() => { [a, b] = [1, 2] }
"#
);
// destructuring_non_iterable
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_non_iterable_exec,
r#"
expect(
() => {
var [foo, bar] = undefined;
}).toThrow();
expect(
() => {
var foo = [ ...undefined ];
}).toThrow();
"#
);
// destructuring_empty_object_pattern
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_empty_object_pattern_exec,
r#"
expect(function () {
var {} = null;
}).toThrow("Cannot destructure null");
"#
);
// destructuring_chained
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_chained_exec,
r#"
var a, b, c, d;
({ a, b } = ({ c, d } = { a: 1, b: 2, c: 3, d: 4}));
expect(a).toBe(1);
expect(b).toBe(2);
expect(c).toBe(3);
expect(d).toBe(4);
"#
);
// destructuring_object_rest_impure_computed_keys
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
)
},
destructuring_object_rest_impure_computed_keys_exec,
r#"
var key, x, y, z;
// impure
key = 1;
var { [key++]: y, ...x } = { 1: 1, a: 1 };
expect(x).toEqual({ a: 1 });
expect(key).toBe(2);
expect(1).toBe(y);
// takes care of the order
key = 1;
var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3};
expect(y).toBe(2);
expect(z).toBe(3);
// pure, computed property should remain as-is
key = 2;
({ [key]: y, z, ...x } = {2: "two", z: "zee"});
expect(y).toBe("two");
expect(x).toEqual({});
expect(z).toBe("zee");
// rhs evaluated before lhs
var order = [];
function left() {
order.push("left");
return 0;
}
function right() {
order.push("right");
return {};
}
var { [left()]: y, ...x} = right();
expect(order).toEqual(["right", "left"]);
"#
);
// destructuring_issue_5090
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_issue_5090_exec,
r#"
const assign = function([...arr], index, value) {
arr[index] = value;
return arr;
}
const arr = [1, 2, 3];
assign(arr, 1, 42);
expect(arr).toEqual([1, 2, 3]);
"#
);
// destructuring_default_precedence
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_default_precedence_exec,
r#"
var f0 = function (a, b = a, c = b) {
return [a, b, c];
};
expect(f0(1)).toEqual([1, 1, 1]);
var f1 = function ({a}, b = a, c = b) {
return [a, b, c];
};
expect(f1({a: 1})).toEqual([1, 1, 1]);
var f2 = function ({a}, b = a, c = a) {
return [a, b, c];
};
expect(f2({a: 1})).toEqual([1, 1, 1]);
"#
);
//// destructuring_es7_object_rest_builtins
//test!(
// syntax(),
// |_| tr(r#"{
// "plugins": [
//
// [destructuring(Default::default()), { "useBuiltIns": true }],
// spread(spread::Config{..Default::default()}),
// parameters(Default::default()),
// block_scoping(),
// object_rest_spread(Default::default()),
// ]
//}
//"#),
// destructuring_es7_object_rest_builtins,
// r#"
//var z = {};
//var { ...x } = z;
//var { x, ...y } = z;
//var { [x]: x, ...y } = z;
//(function({ x, ...y }) { });
//
//({ x, y, ...z } = o);
//
//"#
// r#"
//var z = {};
//var _z = z,
// x = Object.assign({}, _z);
//var _z2 = z,
// x = _z2.x,
// y = _object_without_properties(_z2, ["x"]);
//var _z3 = z,
// x = _z3[x],
// y = _object_without_properties(_z3, [x].map(_to_property_key));
//
//(function (_ref) {
// var x = _ref.x,
// y = _object_without_properties(_ref, ["x"]);
//});
//
//var _o = o;
//x = _o.x;
//y = _o.y;
//z = _object_without_properties(_o, ["x" "y"]);
//_o;
//
//"#
//);
// destructuring_parameters
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_parameters,
r#"
function somethingAdvanced({topLeft: {x: x1, y: y1} = {}, bottomRight: {x: x2, y: y2} = {}}, p2, p3){
}
function unpackObject({title: title, author: author}) {
return title + " " + author;
}
console.log(unpackObject({title: "title", author: "author"}));
var unpackArray = function ([a, b, c], [x, y, z]) {
return a+b+c;
};
console.log(unpackArray(["hello", " ", "world"], [1, 2, 3]));
"#
);
// destructuring_array_unpack_optimisation
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_array_unpack_optimisation,
r#"
var [a, b] = [1, 2];
var [[a, b]] = [[1, 2]];
var [a, b, ...c] = [1, 2, 3, 4];
var [[a, b, ...c]] = [[1, 2, 3, 4]];
var [a, b] = [1, 2, 3];
var [[a, b]] = [[1, 2, 3]];
var [a, b] = [a, b];
[a[0], a[1]] = [a[1], a[0]];
var [a, b] = [...foo, bar];
var [a, b] = [foo(), bar];
var [a, b] = [clazz.foo(), bar];
var [a, b] = [clazz.foo, bar];
var [a, b] = [, 2];
[a, b] = [1, 2];
[a, b] = [, 2];
; // Avoid completion record special case
"#
);
// destructuring_known_array
test!(
// We will use constant propagation instead of optimizing in each pass
ignore,
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_known_array,
r#"
var z = [];
var [x, ...y] = z;
"#
);
// destructuring_es7_object_rest
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_es7_object_rest,
r#"
var z = {};
var { ...x } = z;
var { x, ...y } = z;
var { [x]: x, ...y } = z;
(function({ x, ...y }) { });
({ x, y, ...z } = o);
"#
);
// destructuring_const
test_exec!(
syntax(),
|_| destructuring(Default::default()),
destructuring_const_exec,
r#"
const getState = () => ({});
const { data: { courses: oldCourses = [] } = {} } = getState();
expect(oldCourses).toEqual([]);
"#
);
// destructuring_assignment_expression_pattern
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
)
},
destructuring_assignment_expression_pattern,
r#"
var z = {};
var { x: { y } = {} } = z;
"#
);
// destructuring_object_advanced
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
)
},
destructuring_object_advanced,
r#"
var rect = {};
var {topLeft: {x: x1, y: y1}, bottomRight: {x: x2, y: y2}} = rect;
var { 3: foo, 5: bar } = [0, 1, 2, 3, 4, 5, 6];
"#
);
// destructuring_spread
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
)
},
destructuring_spread,
r#"
function isSorted([x, y, ...wow]) {
if (!zs.length) return true
if (y > x) return isSorted(zs)
return false
}
"#
);
// destructuring_mixed
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
)
},
destructuring_mixed,
r#"
var rect = {};
var {topLeft: [x1, y1], bottomRight: [x2, y2] } = rect;
"#
);
// destructuring_assignment_statement
test!(
syntax(),
|_| (
destructuring(Default::default()),
spread(Default::default()),
block_scoping(Mark::new()),
object_rest_spread(Default::default())
),
destructuring_assignment_statement_no_loose,
r#"
[a, b] = f();
"#
);
// destructuring_assignment_statement_loose
test!(
syntax(),
|_| (
destructuring(Config { loose: true }),
spread(Default::default()),
block_scoping(Mark::new()),
object_rest_spread(Default::default())
),
destructuring_assignment_statement,
r#"
[a, b] = f();
"#
);
// destructuring_array
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_array,
r#"
var [a, [b], [c]] = ["hello", [" ", "junk"], ["world"]];
[a, [b], [c]] = ["hello", [" ", "junk"], ["world"]];
"#
);
// destructuring_assignment_arrow_function_no_block
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_assignment_arrow_function_no_block,
r#"
() => [a, b] = [1, 2]
"#
);
// destructuring_issue_9834
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_issue_9834,
r#"
const input = {};
const {
given_name: givenName,
'last_name': lastName,
[`country`]: country,
[prefix + 'state']: state,
[`${prefix}consents`]: consents,
...rest
} = input;
"#
);
// destructuring_number_key_with_object_rest_spread
test_exec!(
syntax(),
|_| (
object_rest_spread(Default::default()),
destructuring(Default::default())
),
destructuring_number_key_with_object_rest_spread_exec,
r#"
const foo = {
1: "a",
2: "b",
3: "c",
};
const { [1]: bar, ...rest } = foo;
expect(bar).toBe("a");
expect(rest).toEqual({ 2: "b", 3: "c" });
"#
);
// destructuring_for_in
test!(
syntax(),
|_| (
spread(Default::default()),
destructuring(Default::default()),
block_scoping(Mark::new()),
object_rest_spread(Default::default()),
),
destructuring_for_in,
r#"
for (var [name, value] in obj) {
print("Name: " + name + " Value: " + value);
}
for ([name, value] in obj) {
print("Name: " + name + " Value: " + value);
}
"#
);
// destructuring_for_in_loose
test!(
syntax(),
|_| (
spread(Default::default()),
destructuring(Config { loose: true }),
block_scoping(Mark::new()),
object_rest_spread(Default::default()),
),
destructuring_for_in_loose,
r#"
for (var [name, value] in obj) {
print("Name: " + name + " Value: " + value);
}
for ([name, value] in obj) {
print("Name: " + name + " Value: " + value);
}
"#
);
// destructuring_issue_5744
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_issue_5744,
r#"
if (true) [a, b] = [b, a];
"#
);
// destructuring_spread_generator
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
spread(Default::default()),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
block_scoping(unresolved_mark),
object_rest_spread(Default::default()),
)
},
destructuring_spread_generator_exec,
r#"
function* f() {
for (var i = 0; i < 3; i++) {
yield i;
}
}
var [...xs] = f();
expect(xs).toEqual([0, 1, 2]);
"#
);
test!(syntax(), |_| tr(), custom_call, "foo([a, b] = [1, 2])");
test!(
syntax(),
|_| tr(),
issue_1477_1,
"
const [ { a: a_ = 1 } ] = b
"
);
test!(
syntax(),
|_| tr(),
issue_1477_2,
"
async function f(a, b) {
const [ { a: a_ = 1 } ] = JSON.parse(b)
}
"
);
test!(
syntax(),
|_| tr(),
issue_1477_3,
"
const [ a = 1 ] = b
"
);
test!(
syntax(),
|_| tr(),
issue_1477_4,
"
[ a = 1 ] = b
"
);
test!(
syntax(),
|_| tr(),
next_001,
"
const { NODE_ENV }= process.env;
"
);
test!(
syntax(),
|_| tr(),
next_002,
"
({ NODE_ENV }= process.env);
"
);
test!(
syntax(),
|_| tr(),
issue_3315_1,
"\
var baz = 1;
({ foo: bar = baz } = {});
"
);
test!(
syntax(),
|_| tr(),
issue_3315_2,
"\
var baz = 1;
[bar = baz] = [];
"
);
test!(
syntax(),
|_| tr(),
statements_let_dstr_ary_ptrn_elem_id_init_hole,
"\
let [x = 23] = [,];
assert.sameValue(x, 23);
"
);
test!(
syntax(),
|_| tr(),
statements_let_dstr_ary_ptrn_elem_id_init_hole_2,
"\
let y = [x = 23] = [,];
"
);
test!(
syntax(),
|_| tr(),
statements_const_dstr_ary_ptrn_elem_id_init_hole,
"\
const [x = 23] = [,];
assert.sameValue(x, 23);
"
);
test!(
syntax(),
|_| tr(),
statements_const_dstr_ary_ptrn_elem_id_init_hole_2,
"const [x = 23, y = 42] = [,,];"
);
test!(
syntax(),
|_| tr(),
statements_const_dstr_ary_ptrn_elem_id_init_hole_3,
"const [x = 23, y] = [, 42];"
);
test!(
syntax(),
|_| tr(),
statements_const_dstr_ary_ptrn_elem_id_init_hole_4,
"\
function* foo() {
yield 1;
yield 2;
}
let bar = foo();
const [x = bar.next().value, y] = [, bar.next().value];
console.log(x, y);
"
);
test!(
syntax(),
|_| tr(),
for_const_dstr_ary_ptrn_elem_id_init_hole,
"\
var iterCount = 0;
for (const [x = 23] = [,]; iterCount < 1; ) {
assert.sameValue(x, 23);
// another statement
iterCount += 1;
}
assert.sameValue(iterCount, 1, 'Iteration occurred as expected');
"
);
test!(
syntax(),
|_| tr(),
statements_const_id_init_hole,
"\
const [x] = [,];
const [y] = [,], [z] = [,]
"
);
test!(
syntax(),
|_| tr(),
statements_let_id_init_hole,
"let [x] = [,];"
);
test!(syntax(), |_| tr(), issue_6304, "let [] = [];");
test!(syntax(), |_| tr(), issue_6304_1, "let [] = [,];");
test!(syntax(), |_| tr(), issue_6304_2, "let [] = [...[1, 2, 3]];");
test_exec!(
syntax(),
|_| tr(),
issue_7418,
r#"
const truc = { as: "OK"}
function x(as) {
return function g() {
const { as } = truc
console.log(as)
}
as
}
x()();
"#
);
#[testing::fixture("tests/destructuring/**/input.js")]
fn fixture(input: PathBuf) {
let parent = input.parent().unwrap();
let output = parent.join("output.js");
test_fixture(
Syntax::Es(Default::default()),
&|_: &mut swc_ecma_transforms_testing::Tester<'_>| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
destructuring(Default::default()),
)
},
&input,
&output,
Default::default(),
)
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_duplicated_keys.rs | Rust | use swc_ecma_parser::Syntax;
use swc_ecma_transforms_compat::es2015::duplicate_keys;
use swc_ecma_transforms_testing::test;
fn syntax() -> Syntax {
Default::default()
}
test!(
syntax(),
|_| duplicate_keys(),
issue_203,
r#"
const obj = {};
obj.prop = {
alpha: {
charlie: true
},
beta: {
charlie: true,
delta: true
}
};
"#
);
test!(
ignore,
syntax(),
|_| duplicate_keys(),
combination_dupes,
r#"var x = { a: 5, a: 6 };"#
);
test!(
syntax(),
|_| duplicate_keys(),
combination_no_dupes,
r#"var x = { a: 5, b: 6 };"#
);
test!(
syntax(),
|_| duplicate_keys(),
dup_keys_both_quoted,
r#"var x = { "a\n b": 5, "a\n b": 6 };"#
);
test!(
syntax(),
|_| duplicate_keys(),
dup_keys_dupes,
r#"var x = { a: 5, a: 6 };"#
);
test!(
syntax(),
|_| duplicate_keys(),
dup_keys_getter,
r#"var x = { a: 5, get a() {return 6;} };"#
);
test!(
syntax(),
|_| duplicate_keys(),
dup_keys_getter_and_setter,
r#"var x = {
get a() {},
set a(x) {},
get a() {},
set a(x) {},
a: 3,
b: 4,
get b() {},
set b(x) {},
get c() {},
c: 5,
set c(x) {},
set d(x) {},
d: 6,
get d() {}
};"#
);
test!(
syntax(),
|_| duplicate_keys(),
dup_keys_one_quoted,
r#"var x = { a: 5, "a": 6 };"#
);
// duplicate_keys_getter
test!(
syntax(),
|_| duplicate_keys(),
duplicate_keys_getter,
r#"
var x = { a: 5, get a() {return 6;} };
"#
);
// duplicate_keys_dupes
test!(
syntax(),
|_| duplicate_keys(),
duplicate_keys_dupes,
r#"
var x = { a: 5, a: 6 };
"#
);
// duplicate_keys_both_quoted
test!(
syntax(),
|_| duplicate_keys(),
duplicate_keys_both_quoted,
r#"
var x = { "a\n b": 5, "a\n b": 6 };
"#
);
// duplicate_keys_no_dupes
test!(
syntax(),
|_| duplicate_keys(),
duplicate_keys_no_dupes,
r#"
var x = { a: 5, b: 6 };
"#
);
// duplicate_keys_getters_and_setters
test!(
syntax(),
|_| duplicate_keys(),
duplicate_keys_getters_and_setters,
r#"
var x = {
get a() {},
set a(x) {},
get a() {},
set a(x) {},
a: 3,
b: 4,
get b() {},
set b(x) {},
get c() {},
c: 5,
set c(x) {},
set d(x) {},
d: 6,
get d() {}
};
"#
);
// duplicate_keys_one_quoted
test!(
syntax(),
|_| duplicate_keys(),
duplicate_keys_one_quoted,
r#"
var x = { a: 5, "a": 6 };
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_for_of.rs | Rust | use std::{fs::read_to_string, path::PathBuf};
use swc_common::{comments::NoopComments, Mark};
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::es2015::{
self,
for_of::{for_of, Config},
};
use swc_ecma_transforms_testing::{compare_stdout, test, test_exec, test_fixture};
fn syntax() -> Syntax {
Default::default()
}
test!(
syntax(),
|_| for_of(Default::default()),
spec_let,
r#"for (let i of arr) {
}"#
);
test!(
syntax(),
|_| for_of(Default::default()),
spec_member_expr,
r#"for (obj.prop of arr) {
}"#
);
test!(
syntax(),
|_| for_of(Default::default()),
spec_multiple,
r#"for (var i of arr) {
}
for (var i of numbers) {
}
"#
);
test!(
syntax(),
|_| for_of(Default::default()),
spec_nested_label_for_of,
r#"b: for (let c of d()) {
for (let e of f()) {
continue b;
}
}"#
);
test!(
syntax(),
|_| for_of(Default::default()),
spec_var,
r#"for (var i of arr) {
}"#
);
// for_of_as_array_for_of
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
for_of_as_array_for_of,
r#"
let elm;
for (elm of array) {
console.log(elm);
}
"#
);
// for_of_as_array_for_of_array_pattern
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
for_of_as_array_for_of_array_pattern,
r#"
let elm;
for ([elm] of array) {
console.log(elm);
}
"#
);
// regression_redeclare_array_8913
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
regression_redeclare_array_8913,
r#"
function f(...t) {
for (let o of t) {
const t = o;
}
}
"#
);
// for_of_as_array_for_of_declaration_array_pattern
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
for_of_as_array_for_of_declaration_array_pattern,
r#"
for (const [elm] of array) {
console.log(elm);
}
"#
);
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
for_of_as_array_for_of_expression,
r#"
let i;
for (i of items) i;
"#
);
// for_of_as_array_for_of_declaration
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
for_of_as_array_for_of_declaration,
r#"
for (const elm of array) {
console.log(elm);
}
"#
);
// regression_scope_9696
test_exec!(
syntax(),
|_| for_of(Default::default()),
regression_scope_9696_exec,
r#"
var arr = [1, 2, 3];
var results = [];
for (let v of arr) {
results.push(v);
arr = null;
}
expect(results).toEqual([1, 2, 3]);
"#
);
// for_of_as_array_for_of_static_declaration
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
for_of_as_array_for_of_static_declaration,
r#"
const array = [];
for (const elm of array) {
console.log(elm);
}
"#
);
// for_of_as_array_for_of_static
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
for_of_as_array_for_of_static,
r#"
const array = [];
let elm;
for (elm of array) {
console.log(elm);
}
"#
);
// for_of_as_array_for_of_import_es2015
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
for_of_as_array_for_of_import_es2015,
r#"
import { array } from "foo";
for (const elm of array) {
console.log(elm);
}
"#
);
// regression_label_object_with_comment_4995
test!(
syntax(),
|_| for_of(Default::default()),
regression_label_object_with_comment_4995,
r#"
myLabel: //woops
for (let a of b) {
continue myLabel;
}
"#
);
// regression_if_label_3858
test!(
syntax(),
|_| for_of(Config {
assume_array: true,
..Default::default()
}),
regression_if_label_3858,
r#"
if ( true )
loop: for (let ch of []) {
}
"#
);
#[testing::fixture("tests/for-of/**/exec.js")]
fn exec(input: PathBuf) {
let input = read_to_string(input).unwrap();
compare_stdout(
Syntax::default(),
|_| {
let top_level_mark = Mark::new();
(
resolver(Mark::new(), top_level_mark, false),
for_of(Config {
assume_array: false,
..Default::default()
}),
)
},
&input,
);
}
#[testing::fixture("tests/for-of/**/input.js")]
fn fixture(input: PathBuf) {
let output = input.with_file_name("output.js");
test_fixture(
Syntax::default(),
&|_| {
let top_level_mark = Mark::new();
(
resolver(Mark::new(), top_level_mark, false),
for_of(Config {
assume_array: false,
..Default::default()
}),
)
},
&input,
&output,
Default::default(),
);
}
#[testing::fixture("tests/for-of/**/exec.js")]
fn exec_es2015(input: PathBuf) {
let input = read_to_string(input).unwrap();
compare_stdout(
Syntax::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
es2015::es2015(unresolved_mark, Some(NoopComments), Default::default()),
)
},
&input,
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_generator.rs | Rust | #![allow(clippy::unit_arg)]
use swc_common::{
comments::{NoopComments, SingleThreadedComments},
Mark,
};
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015, es2015::generator::generator, es2016, es2017, es2017::async_to_generator, es2018,
es2021, es2022,
};
use swc_ecma_transforms_testing::{test, test_exec};
fn syntax() -> Syntax {
Syntax::default()
}
fn tr(_: ()) -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
generator(unresolved_mark, NoopComments),
)
}
fn tr_with_async() -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
async_to_generator(Default::default(), unresolved_mark),
generator(unresolved_mark, NoopComments),
)
}
// computed_properties_example
test!(
syntax(),
|_| tr(Default::default()),
computed_properties_example,
r#"
var o = {
*foo() {
return "foo";
}
};
"#
);
// class_argument_scope_example
test_exec!(
syntax(),
|_| tr(Default::default()),
class_argument_scope_example_exec,
r#"
class Test {
*iter(arg = this) {
yield arg;
}
}
let test = new Test;
expect(test.iter().next().value).toBe(test);
"#
);
//// regression_T7041
//test!(
// syntax(),
// |_| tr(Default::default()),
// regression_t7041,
// r#"
//var _regeneratorRuntime = require("regenerator-runtime");
//
//Object.keys({});
//
//function * fn(){}
//
//"#
// r#"
//var _regeneratorRuntime = require("regenerator-runtime");
//
//var _marked = _regeneratorRuntime.mark(fn);
//
//Object.keys({});
//
//function fn() {
// return _regeneratorRuntime.wrap(function fn$(_ctx) {
// while (1) {
// switch (_ctx.prev = _ctx.next) {
// case 0:
// case "end":
// return _ctx.stop();
// }
// }
// }, _marked);
//}
//
//"#
//);
test!(
syntax(),
|_| tr(Default::default()),
empty_fn_decl_1,
"function* foo(a,b,c){}
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
conditional_return_1,
"
let v = (function* (){
yield 3;
if (true)
return 1
})();
expect(v.next()).toEqual({ value: 3, done: false });
expect(v.next()).toEqual({ value: 1, done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
conditional_return_2,
"
let v = (function* (){
if (false)
return a
yield 1
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
conditional_return_exec_1,
"
let v = (function* (){
yield 3;
if (true)
return 2;
yield 1
})();
expect(v.next()).toEqual({ done: false, value: 3 });
expect(v.next()).toEqual({ done: true, value: 2 });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
conditional_return_exec_2,
"
let v = (function* (){
yield 3;
if (false)
return 2;
yield 1
})();
expect(v.next()).toEqual({ done: false, value: 3 });
expect(v.next()).toEqual({ done: false, value: 1 });
expect(v.next()).toEqual({ done: true, value: undefined });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
conditional_yield_1,
"
let v = (function* () {
if (true)
yield 1
})();
expect(v.next()).toEqual({ done: false, value: 1 });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
conditional_yield_2,
"
let v = (function* () {
if (true)
yield 1
if (false)
yield 2
yield 3
})();
expect(v.next()).toEqual({ done: false, value: 1 });
expect(v.next()).toEqual({ done: false, value: 3 });
expect(v.next()).toEqual({ done: true, value: undefined });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
yield_in_seq,
"
let v = (function* () {
return (1, yield 2, yield 3, 4, yield 5);
})();
expect(v.next()).toEqual({ done: false, value: 2 });
expect(v.next()).toEqual({ done: false, value: 3 });
expect(v.next()).toEqual({ done: false, value: 5 });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
yield_in_cond_seq,
"
let v = (function* () {
if (true)
return (1, yield 2, yield 3, 4, yield 5);
})();
expect(v.next()).toEqual({ done: false, value: 2 });
expect(v.next()).toEqual({ done: false, value: 3 });
expect(v.next()).toEqual({ done: false, value: 5 });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
yield_in_return_and_call,
"
function id(v) { return v; }
let v = (function* () {
if (true)
return (1, id(yield id(2)));
})();
expect(v.next()).toEqual({ done: false, value: 2 });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
yield_in_call,
"
function id(v) { return v; }
let v = (function* () {
return (1, id(yield id(2)));
return (3, id(yield id(4)));
})();
expect(v.next()).toEqual({ done: false, value: 2 });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
ignore,
syntax(),
|_| tr(Default::default()),
yield_temp,
"
function id(v) { return v; }
let v = (function* () {
yield (1, id(yield id(2), 2));
return (3, id(yield id(4)));
})();
expect(v.next()).toEqual({ done: false, value: 2 });
expect(v.next()).toEqual({ done: false, value: 2 });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
ignore,
syntax(),
|_| tr(Default::default()),
yield_next_value,
"
let v = (function* () {
let bar = yield 'foo';
yield bar
})();
expect(v.next('bar')).toEqual({value: 'foo', done: false})
expect(v.next()).toEqual({value: 'bar', done: false})
expect(v.next()).toEqual({done: true})
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
only_yield,
"
let v = (function* () {
yield 1
})();
expect(v.next()).toEqual({ done: false, value: 1 });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
expr_cond,
"
let v = (function* (){
true ? yield 1 : yield 2;
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
expr_array,
"
let v = (function* (){
yield [yield 1, 2];
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: [undefined, 2], done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
expr_object,
"
let v = (function* (){
yield { a: 1 };
})();
expect(v.next()).toEqual({ value: { a: 1 }, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
expr_logical_and,
"
let v = (function* (){
(yield 1) && (yield 2);
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
expr_logical_or,
"
let v = (function* (){
(yield 1) || (yield 2);
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
expr_update_prefix,
"
let v = (function* (){
let i = 0;
yield ++i;
yield i;
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
expr_update_postfix,
"
let v = (function* (){
let i = 0;
yield i++;
yield i;
})();
expect(v.next()).toEqual({ value: 0, done: false });
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
bin_expr_1,
"
let v = (function* (){
yield ((yield 1) + (yield 2));
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ value: NaN, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
try_stmt_1,
"
let v = (function* (){
try {
yield 1;
} catch(e){
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
try_stmt_2,
"
let v = (function* (){
try {
yield 1;
throw new Error('');
} catch(e){
yield 2;
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
try_stmt_3,
"
let v = (function* (){
try {
yield 1;
throw new Error('');
} finally {
yield 2;
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(() => v.next()).toThrow();
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
try_stmt_4,
"
let v = (function* (){
try {
yield 1;
throw new Error('');
} catch (e) {
yield 2;
} finally {
yield 3;
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ value: 3, done: false });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
try_stmt_5,
"
let v = (function* (){
try {
yield 1;
} catch (e) {
}
try {
yield 2;
} catch (e) {
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
"
);
// TODO
test_exec!(
syntax(),
|_| tr(Default::default()),
labeled_stmt_1,
"
let v = (function* (){
})();
expect(v.next()).toEqual({ done: true });
"
);
// TODO
test_exec!(
syntax(),
|_| tr(Default::default()),
break_stmt_1,
"
let v = (function* (){
})();
expect(v.next()).toEqual({ done: true });
"
);
// TODO
test_exec!(
syntax(),
|_| tr(Default::default()),
continue_stmt_1,
"
let v = (function* (){
})();
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
switch_stmt_1,
"
let v = (function* (){
switch(1) {
case 1:
yield 1
yield 2
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
switch_stmt_2,
"
let v = (function* (){
switch(2) {
case 1:
yield 1
yield 2
}
})();
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
switch_stmt_3,
"
let v = (function* (){
switch(2) {
default:
yield 1
yield 2
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
switch_stmt_4,
"
let v = (function* (){
switch(1) {
case 1:
yield 1
case 2:
yield 2
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
switch_stmt_5,
"
let v = (function* (){
switch(1) {
case 1:
yield 1;
break;
case 2:
yield 2;
break;
case 3:
yield 3;
break;
case 4:
yield 4;
break;
}
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ done: true });
"
);
// TODO
test_exec!(
syntax(),
|_| tr(Default::default()),
throw_stmt_1,
"
let v = (function* (){
})();
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
while_stmt_1,
"
let v = (function* (){
let i = 0;
while (true) {
yield i++;
}
})();
expect(v.next()).toEqual({ value: 0, done: false });
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ value: 3, done: false });
expect(v.next()).toEqual({ value: 4, done: false });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
do_while_stmt_1,
"
let v = (function* (){
let i = 0;
do {
yield i++;
} while(true);
})();
expect(v.next()).toEqual({ value: 0, done: false });
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ value: 3, done: false });
expect(v.next()).toEqual({ value: 4, done: false });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
do_while_stmt_2,
"
let v = (function* (){
do {
yield 1;
} while(false);
})();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ done: true });
"
);
// TODO
test_exec!(
syntax(),
|_| tr(Default::default()),
for_stmt_1,
"
let v = (function* (){
})();
expect(v.next()).toEqual({ done: true });
"
);
// TODO
test_exec!(
syntax(),
|_| tr(Default::default()),
for_of_stmt_1,
"
let v = (function* (){
})();
expect(v.next()).toEqual({ done: true });
"
);
// TODO
test_exec!(
syntax(),
|_| tr(Default::default()),
for_in_stmt_1,
"
let v = (function* (){
})();
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
bin_expr_2,
"
let v = (function* (){
let a = 1;
let b = 2;
yield a + b;
yield (yield a) + (yield b)
})();
expect(v.next()).toEqual({ value: 3, done: false });
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ value: NaN, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
arguments_1,
"
function* gen(){
yield Array.prototype.slice.call(arguments);
}
var v = gen(1, 2);
expect(v.next()).toEqual({ value: [1, 2], done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
arguments_2,
"
function* gen(){
yield arguments[0];
yield arguments[1];
}
var v = gen(1, 2);
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ done: true });
var v = gen(3, 4);
expect(v.next()).toEqual({ value: 3, done: false });
expect(v.next()).toEqual({ value: 4, done: false });
expect(v.next()).toEqual({ done: true });
"
);
test_exec!(
syntax(),
|t| {
let unresolved_mark = Mark::new();
(
es2017(Default::default(), unresolved_mark),
es2016(),
es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
issue_600_full,
"async function foo(b) {
for (let a of b) {
await a
}
}"
);
test_exec!(
syntax(),
|t| {
let unresolved_mark = Mark::new();
(
async_to_generator(Default::default(), unresolved_mark),
es2015::for_of(Default::default()),
generator(unresolved_mark, t.comments.clone()),
)
},
issue_600_exact_passes,
"async function foo(b) {
for (let a of b) {
await a
}
}"
);
test_exec!(
syntax(),
|t| generator(Mark::new(), t.comments.clone()),
issue_600_min,
"function* foo() {
try {
yield 1;
throw new Error('1')
} finally{
try {
yield 2;
} finally{
throw new Error('2');
}
}
}
var v = foo();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(() => v.next()).toThrow('2')
"
);
test_exec!(
syntax(),
|t| generator(Mark::new(), t.comments.clone()),
issue_831_1,
"function* myGenerator() {
yield* [1,2,3];
}
const v = myGenerator();
expect(v.next()).toEqual({ value: 1, done: false });
expect(v.next()).toEqual({ value: 2, done: false });
expect(v.next()).toEqual({ value: 3, done: false });
expect(v.next()).toEqual({ done: true });
"
);
// test interop between export and regenerator
test!(
syntax(),
|t| generator(Mark::new(), t.comments.clone()),
issue_831_3,
"export function* myGenerator() {
yield* [1,2,3];
}"
);
test_exec!(
syntax(),
|t| generator(Mark::new(), t.comments.clone()),
delegate_context,
"function* a() {
yield 5;
return 7;
}
function* b() {
let x = yield* a();
yield (x + 1);
}
expect([...b()]).toEqual([5, 8]);"
);
test_exec!(
syntax(),
|t| generator(Mark::new(), t.comments.clone()),
issue_849_1,
"function* gen() { yield 1 };
function genFactory() { return function*() { yield 1 }; }
const v = genFactory()();
expect(v.next()).toEqual({ value: 1, done: false })
expect(v.next()).toEqual({ done: true })"
);
test_exec!(
syntax(),
|t| generator(Mark::new(), t.comments.clone()),
issue_853_1,
"function throwingFn() { throw 'Error' }
function* gen() {
try { yield throwingFn() } catch (e) { yield e }
};
const v = gen();
expect(v.next()).toEqual({ done: false, value: 'Error'});
"
);
test_exec!(
Syntax::default(),
|_| tr_with_async(),
issue_1036_1,
"
const x = async function() {
return await Promise.all([[1], [2], [3]].map(
async ([a]) => Promise.resolve().then(() => a * 2))
)
};
return x().then(x => {
expect(x).toEqual([2, 4, 6])
})
"
);
test!(
Syntax::default(),
|_| tr(()),
issue_1036_2,
"
const x = function*() {
return Promise.all([[1], [2], [3]].map(
function*([a]) {
Promise.resolve().then(() => a * 2)
})
)
}
"
);
test_exec!(
Syntax::default(),
|_| tr(()),
issue_1036_3,
"
const x = function*() {
yield* [[1], [2], [3]].map(function([a]) {
return a * 2
})
}
const v = x();
expect(v.next()).toEqual({ value: 2, done: false})
expect(v.next()).toEqual({ value: 4, done: false})
expect(v.next()).toEqual({ value: 6, done: false})
expect(v.next()).toEqual({ done: true})
"
);
test_exec!(
Syntax::default(),
|_| tr_with_async(),
issue_1125_1,
"
async function test() {
try {
await 1
} finally {
console.log(2)
}
}
test()
"
);
test!(
Syntax::default(),
|_| tr(()),
hoist_function_in_generator_issue_2556_1,
r#"
function* foo() {
return bar;
function bar() { }
}
"#
);
test_exec!(
Syntax::default(),
|_| tr_with_async(),
hoist_function_in_async_issue_2556_2,
"
async function foo() {
return bar;
async function bar() {
return 1;
}
async function bar() {
return 2;
}
async function bar() {
return 3;
}
}
return foo()
.then((bar) => bar())
.then((x) => {
expect(x).toEqual(3);
});
"
);
test!(
Syntax::default(),
|_| tr_with_async(),
hoist_function_in_async_issue_2556_4,
r#"
function requester() {
return pureRequester
async function pureRequester() {
await refreshThenRequest()
return true;
async function refreshThenRequest() {
}
}
}
"#
);
test_exec!(
Syntax::default(),
|_| tr_with_async(),
hoist_function_in_async_issue_2556_5,
r#"
function requester() {
return pureRequester;
async function pureRequester() {
await refreshThenRequest();
return true;
async function refreshThenRequest() {}
}
}
return requester()().then(function test(result) {
expect(result).toBe(true);
});
"#
);
test_exec!(
Syntax::default(),
|_| tr_with_async(),
issue_2620,
r#"
async function main() {
class Weird1 {
weird = async () => {
return !!this;
};
decoy1 = async () => {};
decoy2 = () => {};
}
class Weird2 {
weird = async () => {
return !!this;
};
// decoy1 = async () => { };
decoy2 = () => {};
}
class Weird3 {
weird = async () => {
return !!this;
};
decoy1 = async () => {};
// decoy2 = () => { };
}
class Weird4 {
decoy1 = async () => {};
decoy2 = () => {};
weird = async () => {
return !!this;
};
}
return Promise.all([
new Weird4().weird(),
new Weird3().weird(),
new Weird2().weird(),
new Weird1().weird(),
]);
}
return main().then((results) => {
expect(results).toEqual([true, true, true, true]);
});
"#
);
test!(
Syntax::default(),
|_| tr_with_async(),
hoist_function_in_async_issue_2556_6,
r#"
async function foo(a) {
return bar1;
async function bar1(b) {
return a + b;
}
}
foo(1)
.then((t) => t(2))
.then(console.log);
"#
);
test_exec!(
Syntax::default(),
|_| tr_with_async(),
hoist_function_in_async_issue_2556_7,
r#"
async function foo(a) {
return bar1;
async function bar1(b) {
return a + b;
}
}
return foo(1)
.then((t) => t(2))
.then((result) => {
expect(result).toBe(3);
});
"#
);
test!(
Syntax::default(),
|_| tr_with_async(),
hoist_function_in_async_issue_2556_8,
r#"
var fib = function fib() {
return 42;
};
async function init() {
return fib;
async function fib(n) {
if (n <= 1) {
return n;
}
const x = await fib(n - 1);
const y = await fib(n - 2);
return x + y;
}
}
"#
);
test!(
Syntax::default(),
|_| tr(()),
issue_1125_2,
"
function _test() {
_test = _async_to_generator(function* () {
try {
yield 1;
} finally {
console.log(2);
}
});
return _test.apply(this, arguments);
}
function test() {
return _test.apply(this, arguments);
}
test();
"
);
test!(
Syntax::default(),
|_| tr(()),
issue_1125_3,
"
function* foo() {
try {
yield 1;
} finally {
console.log(2);
}
}
"
);
test!(
Syntax::default(),
|_| tr(()),
issue_1125_4,
"
function* foo() {
try {
yield 1;
} catch(e) {
console.log(2);
}
}
"
);
test!(
Syntax::default(),
|_| tr_with_async(),
issue_1799_1,
"
export default function Foo() {
return call(async (e) => { await doSomething(); })
}
"
);
test!(
Syntax::default(),
|_| {
let mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), mark),
es2015::<SingleThreadedComments>(mark, None, Default::default()),
)
},
issue_1799_2,
"
export default function Foo() {
return call(async (e) => { await doSomething(); })
}
"
);
test!(
Syntax::default(),
|_| {
let mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), mark),
es2016(),
es2015::<SingleThreadedComments>(mark, None, Default::default()),
)
},
issue_1799_3,
"
export default function Foo() {
return call(async (e) => { await doSomething(); })
}
"
);
test!(
Syntax::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
es2022(Default::default(), unresolved_mark),
es2021(),
es2018(Default::default()),
es2017(Default::default(), unresolved_mark),
es2016(),
es2015::<SingleThreadedComments>(unresolved_mark, None, Default::default()),
)
},
issue_1799_5,
"
export default function Foo() {
return call(async (e) => { await doSomething(); })
}
"
);
test!(
Syntax::default(),
|_| {
let mark = Mark::fresh(Mark::root());
es2015::<SingleThreadedComments>(mark, None, Default::default())
},
issue_2024_1,
"
_async_to_generator(function*() {
const sleep = ()=>new Promise((resolve)=>setTimeout(()=>resolve(undefined), 500));
const result = (yield sleep()) || 'fallback';
console.log(result);
})();
"
);
test_exec!(
Syntax::default(),
|t| {
let mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), mark),
es2015::for_of(Default::default()),
generator(mark, t.comments.clone()),
)
},
issue_1918_1,
"
let counter = 0;
let resolve;
let promise = new Promise((r) => (resolve = r));
let iterable = {
[Symbol.asyncIterator]() {
return {
next() {
return promise;
},
};
},
};
const res = (async () => {
for await (let value of iterable) {
counter++;
console.log(value);
}
expect(counter).toBe(2);
})();
for (let v of [0, 1]) {
await null;
let oldresolve = resolve;
promise = new Promise((r) => (resolve = r));
oldresolve({ value: v, done: false });
}
resolve({ value: undefined, done: true });
await res;
"
);
test!(
Syntax::default(),
|_| {
let mark = Mark::fresh(Mark::root());
es2015::<SingleThreadedComments>(mark, None, Default::default())
},
issue_7809,
r#"
function a(fn) {
return _a.apply(this, arguments);
}
function _a() {
_a = _async_to_generator(function*(fn) {
(yield fn()).a = 1;
});
return _a.apply(this, arguments);
}
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_new_target.rs | Rust | use std::{fs::read_to_string, path::PathBuf};
use serde::Deserialize;
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015::{arrow, classes, new_target::new_target},
es2022::class_properties,
};
use swc_ecma_transforms_testing::{exec_tr, parse_options, test, test_fixture, Tester};
fn get_passes(_: &Tester, plugins: &[PluginConfig]) -> Box<dyn Pass> {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
let mut pass: Box<dyn Pass> = Box::new(resolver(unresolved_mark, top_level_mark, true));
for plugin in plugins {
let (name, option) = match plugin {
PluginConfig::WithOption(name, config) => (name, config.clone()),
PluginConfig::Name(name) => (name, serde_json::Value::Null),
};
let loose = option
.as_object()
.and_then(|opt| opt.get("loose"))
.and_then(|loose| {
if let Some(true) = loose.as_bool() {
Some(())
} else {
None
}
})
.is_some();
match &**name {
"transform-new-target" => {}
"proposal-class-properties" => {
pass = Box::new((
pass,
class_properties(
class_properties::Config {
constant_super: loose,
set_public_fields: loose,
private_as_properties: loose,
no_document_all: loose,
pure_getter: loose,
},
unresolved_mark,
),
));
}
"transform-arrow-functions" => {
pass = Box::new((pass, arrow(Mark::new())));
}
_ => {
panic!("unknown pass: {}", name)
}
}
}
pass = Box::new((pass, new_target()));
pass
}
#[testing::fixture("tests/new-target/**/exec.js")]
fn exec(input: PathBuf) {
let options: TestOptions = parse_options(&input);
let input = read_to_string(&input).unwrap();
exec_tr(
"new-target",
Default::default(),
|t| get_passes(t, &options.plugins),
&input,
);
}
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
struct TestOptions {
plugins: Vec<PluginConfig>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(untagged)]
enum PluginConfig {
WithOption(String, #[serde(default)] serde_json::Value),
Name(String),
}
#[testing::fixture("tests/new-target/**/input.js")]
fn fixture(input: PathBuf) {
let options: TestOptions = parse_options(&input);
let output = input.parent().unwrap().join("output.js");
test_fixture(
Default::default(),
&|t| get_passes(t, &options.plugins),
&input,
&output,
Default::default(),
)
}
test!(
::swc_ecma_parser::Syntax::default(),
|_| (classes(Default::default()), new_target()),
issue_6259,
r#"
(() => {
var SomeError = class extends Error {
constructor(issues) {
super();
const actualProto = new.target.prototype;
}
}
})();
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_object_super.rs | Rust | use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::es2015::{function_name, object_super, shorthand};
use swc_ecma_transforms_testing::test;
fn syntax() -> Syntax {
::swc_ecma_parser::Syntax::default()
}
fn tr() -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_super(),
shorthand(),
function_name(),
)
}
test!(
syntax(),
|_| tr(),
get_semantics_data_defined_on_parent,
r#"
const Base = {
test: 1,
};
const obj = {
test: 2,
get() {
return super.test;
},
};
Object.setPrototypeOf(obj, Base);"#
);
test!(
syntax(),
|_| tr(),
set_semantics_data_defined_on_parent,
r#"
const Base = {
test: 1,
};
const obj = {
test: 2,
set() {
return super.test = 3;
},
};
Object.setPrototypeOf(obj, Base);"#
);
test!(
syntax(),
|_| tr(),
nested_object_super_property_in_key,
r#"
const Hello = {
toString() {
return 'hello';
}
};
const Outer = {
constructor() {
const Inner = {
[super.toString()]() {
return 'hello';
},
};
return Inner;
}
};
Object.setPrototypeOf(Outer, Hello);"#
);
test!(
syntax(),
|_| tr(),
super_increment_postfix,
r#"var Base = {
test: "1"
};
var obj = {
bar() {
return super.test++;
}
};
Object.setPrototypeOf(obj, Base);"#
);
test!(
syntax(),
|_| tr(),
super_increment_postfix2,
r#"var Base = {
test: "1"
};
var obj = {
bar() {
return super[test]++;
}
};
Object.setPrototypeOf(obj, Base);"#
);
test!(
syntax(),
|_| tr(),
super_increment_prefix,
r#"var Base = {
test: "1"
};
var obj = {
bar() {
return ++super.test;
}
};
Object.setPrototypeOf(obj, Base);"#
);
test!(
syntax(),
|_| tr(),
nested_object,
r#"
function f0() {
}
f0.prototype = {
name: 'Nicholas',
age: 29,
job: 'Software Engineer',
sayName() {
v0[args](1, {
v9: v7 => super.v3(v27),
foo: a,
done: 'a'
});
}
};
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_parameters.rs | Rust | use std::path::PathBuf;
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015::{
arrow, block_scoping, classes, destructuring, parameters, parameters::Config, spread,
},
es2017::async_to_generator,
};
use swc_ecma_transforms_testing::{test, test_exec, test_fixture};
fn syntax() -> Syntax {
Default::default()
}
fn tr(c: Config) -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(c, unresolved_mark),
destructuring(destructuring::Config { loose: false }),
block_scoping(unresolved_mark),
)
}
test!(
syntax(),
|_| tr(Default::default()),
issue_254,
"export const someFunction = (update = false, action = {}) => {}"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_227,
"export default function fn1(...args) {
fn2(...args);
}"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_169,
r#"
class Foo {
func(a, b = Date.now()) {
return {a};
}
}
"#
);
test!(
syntax(),
|_| tr(Default::default()),
babel_6057_simple,
r#"const a = 'bar';
function foo(...a) {
return a;
}"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_before_last,
r#"function foo({x,y} = "foo", b) {}"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
default_destructuring,
r#"function required(msg) {
throw new Error(msg);
}
function sum(
{ arr = required('arr is required') } = { arr: arr = [] },
length = arr.length
) {
let i = 0;
let acc = 0;
for (let item of arr) {
if (i >= length) return acc;
acc += item;
i++;
}
return acc;
}
expect(sum({arr:[1,2]})).toBe(3);"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
default_earlier_params,
r#"function f(a, b = a, c = b) { return c; }
expect(3).toBe(f(3));"#
);
test!(
ignore,
syntax(),
|_| tr(Default::default()),
default_eval,
r#"let x = "outside";
function outer(a = () => eval("x")) {
let x = "inside";
return a();
}
outer();"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
default_iife_1128,
r#"const bar = true;
function foo(a = bar, ...b) {
const bar = false;
expect(b[0]).toBe(2);
expect(b[1]).toBe(3);
}
foo(1, 2, 3);"#
);
test!(
syntax(),
|_| (classes(Default::default()), tr(Default::default())),
default_iife_4253,
r#"class Ref {
constructor(id = ++Ref.nextID) {
this.id = id
}
}
Ref.nextID = 0"#
);
test_exec!(
ignore,
syntax(),
// Stage0
|_| tr(Default::default()),
default_iife_4253_exec,
r#"class Ref {
static nextId = 0
constructor(id = ++Ref.nextId, n = id) {
this.id = n
}
}
expect(new Ref().id).toBe(1);
expect(new Ref().id).toBe(2);"#
);
test!(
syntax(),
|_| (classes(Default::default()), tr(Default::default())),
default_iife_self,
r#"class Ref {
constructor(ref = Ref) {
this.ref = ref
}
}
class X {
constructor(x = foo) {
this.x = x
}
}"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
default_iife_self_exec,
r#"class Ref {
constructor(ref = Ref) {
this.ref = ref
}
}
expect(new Ref().ref).toBe(Ref);"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_multiple,
r#"var t = function (e = "foo", f = 5) {
return e + " bar " + f;
};
var a = function (e, f = 5) {
return e + " bar " + f;
};"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_rest_mix,
r#"function fn(
a1,
a2 = 4,
{a3, a4},
a5,
{a6, a7} = {}) {}"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_rest_1,
r#"const a = 1;
function rest(b = a, ...a) {
expect(b).toBe(1);
}
rest(undefined, 2)"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_rest_2,
r#"const a = 1;
function rest2(b = a, ...a) {
expect(a[0]).toBe(2);
}
rest2(undefined, 2);"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_rest_3,
r#"const a = 1;
function rest3(b = a, ...a) {
expect(a).toHaveLength(1);
}
rest3(undefined, 2)"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
default_rest_exec,
r#"const a = 1;
function rest(b = a, ...a) {
expect(b).toBe(1);
}
rest(undefined, 2)
function rest2(b = a, ...a) {
expect(a[0]).toBe(2);
}
rest2(undefined, 2)
function rest3(b = a, ...a) {
expect(a).toHaveLength(1);
}
rest3(undefined, 2)"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_setter_noexec,
r#"const obj = {
set field(num = 1) {
this.num = num;
}
};"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_setter_complex,
r#"const obj = {
set obj({ a, b } = {}) {
this.num = { a, b };
},
set arr([x, y] = []) {
this.num = { x, y }
}
};"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
default_setter_exec,
r#"const defaultValue = 1;
const obj = {
set field(num = defaultValue) {
this.num = num;
}
};
obj.field = void 0;
expect(obj.num).toBe(defaultValue);"#
);
test!(
syntax(),
|_| tr(Default::default()),
default_single,
r#"var t = function (f = "foo") {
return f + " bar";
};"#
);
test!(
syntax(),
|_| tr(Default::default()),
destructuring_rest,
r#"// #3861
function t(x = "default", { a, b }, ...args) {
console.log(x, a, b, args);
}"#
);
test!(
syntax(),
|_| tr(Default::default()),
regression_4333,
r#"const args = 'bar';
function foo(...args) {
return args;
}"#
);
test!(
syntax(),
|_| tr(Default::default()),
regression_4348,
r#"function first(...values) {
var index = 0;
return values[index++];
}"#
);
test!(
ignore,
syntax(),
// type
|_| tr(Default::default()),
regression_4634,
r#"let oneOf = (...nodes) => {
if (nodes.length === 1) {
return nodes[0];
}
return ((new OneOfNode(nodes)): any)
}"#
);
test!(
syntax(),
|_| tr(Default::default()),
regression_5787,
r#"function f(a, ...rest) {
let b = rest[rest.length - 3];
let c = rest[rest.length - 2];
let d = rest[rest.length - 1];
return [a, b, c, d];
}
function f(a, ...rest) {
return rest[-1];
}"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
regression_5787_exec,
r#"function f1(a, ...rest) {
let b = rest[rest.length - 3];
let c = rest[rest.length - 2];
let d = rest[rest.length - 1];
return [a, b, c, d];
}
expect(f1(1, 2)).toEqual([1, undefined, undefined, 2]);
function f2(a, ...rest) {
return rest[-1];
}
expect(f2(1, 2)).toBeUndefined();"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_args_deoptimiazation,
r#"function x (...rest) {
arguments;
}"#
);
test!(
// Stage 0
ignore,
syntax(),
|_| tr(Default::default()),
rest_arrow_fn,
r#"var concat = (...arrs) => {
var x = arrs[0];
var y = arrs[1];
};
var somefun = function () {
let get2ndArg = (a, b, ...args) => {
var _b = args[0];
let somef = (x, y, z, ...args2) => {
var _a = args2[0];
};
let somefg = (c, d, e, f, ...args3) => {
var _a = args3[0];
};
var _d = args[1];
};
let get3rdArg = (...args) => args[2];
}
function demo1(...args) {
return (i) => {
return args[i+0];
};
}
var x = (...rest) => {
if (noNeedToWork) return 0;
return rest;
};
var innerclassproperties = (...args) => (
class {
static args = args;
args = args;
}
);"#
);
test!(
ignore,
syntax(),
|_| tr(Default::default()),
rest_async_arrow_fn,
r#"var concat = async (...arrs) => {
var x = arrs[0];
var y = arrs[1];
};
var x = async (...rest) => {
if (noNeedToWork) return 0;
return rest;
};"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
arrow(unresolved_mark),
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
destructuring(destructuring::Config { loose: false }),
block_scoping(unresolved_mark),
)
},
rest_binding_deoptimisation,
r#"const deepAssign = (...args) => args = [];
"#
);
test!(
// optimization is not implemented
ignore,
syntax(),
|_| tr(Default::default()),
rest_deepest_common_ancestor_earliest_child,
r#"// single reference
function r(...rest){
if (noNeedToWork) return 0;
return rest;
}
// multiple references
function r(...rest){
if (noNeedToWork) return 0;
rest;
rest;
}
// multiple nested references
function r(...rest){
if (noNeedToWork) return 0;
if (true) {
return rest;
} else {
return rest;
}
}
// deeply nested
function r(...rest){
if (true) {
if (true) {
return rest;
} else {
return rest;
}
}
}
// nested reference with root reference
function r(...rest){
if (noNeedToWork) return 0;
if (lol) rest;
rest;
}
// nested functions
function a(...args) {
return function() {
function b() {}
console.log("Shouldn't args be from a's scope?" args);
};
}
// loop
function runQueue(queue, ...args) {
for (let i = 0; i < queue.length; i++) {
queue[i](...args)
}
}
// nested loop
function runQueue(queue, ...args) {
if (foo) {
for (let i = 0; i < queue.length; i++) {
queue[i](...args)
}
}
}
function r(...rest){
if (noNeedToWork) return 0;
[rest[0]] = x;
return rest;
}"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_length,
r#"var t = function (f, ...items) {
items[0];
items[items.length - 1];
};
function t(f, ...items) {
items;
items[0];
items[items.length - 1];
}"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_length_exec,
r#"var length = function (a, b, ...items) {
return items.length;
};
expect(length()).toBe(0);
expect(length(1)).toBe(0);
expect(length(1, 2)).toBe(0);
expect(length(1, 2, 3)).toBe(1);"#
);
test!(
// optimisation is not implemented
ignore,
syntax(),
|_| tr(Default::default()),
rest_member_expression_deoptimisation,
r#"var t = function (...items) {
var x = items[0];
var y = items[1];
}
function t(...items) {
var x = items[0];
var y = items[1];
}
function t(...items) {
var a = [];
for (var i = 0; i < items.length; i++) {
a.push(i);
}
return a;
}
// https://github.com/babel/babel/pull/2833#issuecomment-166039291
function t(...items) {
for (let i = 0; i < items.length; i++) {
return items[i];
}
}"#
);
test!(
// optimisation is not implemented
ignore,
syntax(),
|_| tr(Default::default()),
rest_member_expression_optimisation,
r#"var t = function (...items) {
var x = items[0];
var y = items[1];
}
function t(...items) {
var x = items[0];
var y = items[1];
}
function t(...items) {
var a = [];
for (var i = 0; i < items.length; i++) {
a.push(i);
}
return a;
}
// https://github.com/babel/babel/pull/2833#issuecomment-166039291
function t(...items) {
for (let i = 0; i < items.length; i++) {
return items[i];
}
}"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_multiple,
r#"var t = function (f, ...items) {
var x = f;
x = items[0];
x = items[1];
};
function t(f, ...items) {
var x = f;
x = items[0];
x = items[1];
}
function u(f, g, ...items) {
var x = f;
var y = g;
x[12] = items[0];
y.prop = items[1];
var z = items[2] | 0 || 12;
}"#
);
test!(
// optimisation is not implemented
ignore,
syntax(),
|_| tr(Default::default()),
rest_nested_5656,
r#"function a(...args) {
const foo = (...list) => bar(...list);
foo(...args);
}
function b(...args) {
const foo = (...args) => bar(...args);
foo(...args);
}
function c(...args) {
const foo = (...args) => bar(...args);
foo([]);
}
function d(thing, ...args) {
const foo = (...args) => bar(...args);
{
let args = thing;
foo(thing);
}
}"#
);
test!(
syntax(),
|_| (
tr(Default::default()),
classes(Default::default()),
spread(Default::default())
),
rest_nested_iife,
r#"function broken(x, ...foo) {
if (true) {
class Foo extends Bar { }
return hello(...foo)
}
}"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_patterns,
r#"function foo(...[a]) {}"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_patterns_exec,
r#"
function foo(...{ length }) {
return length;
}
expect(foo(1, 2, 3)).toEqual(3);"#
);
test!(
// optimisation is not implemented
ignore,
syntax(),
|_| tr(Default::default()),
rest_spread_optimisation,
r#"// optimisation
function foo(...bar) {
foo(...bar);
}
// deoptimisation
function foo(a, ...b) {
foo(...b);
}
function foo(...b) {
foo(1, ...b);
}
function foo(...args){
args.pop()
foo(...args);
}"#
);
// parameters_rest_async_arrow_functions
test!(
// See https://github.com/swc-project/swc/issues/490
ignore,
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
async_to_generator(Default::default(), unresolved_mark),
arrow(unresolved_mark),
parameters(Default::default(), unresolved_mark),
)
},
parameters_rest_async_arrow_functions_1,
r#"
var concat = async (...arrs) => {
var x = arrs[0];
var y = arrs[1];
};
"#
);
// parameters_rest_async_arrow_functions
test!(
// See https://github.com/swc-project/swc/issues/490
ignore,
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
async_to_generator(Default::default(), unresolved_mark),
arrow(unresolved_mark),
parameters(Default::default(), unresolved_mark),
)
},
parameters_rest_async_arrow_functions_2,
r#"
var x = async (...rest) => {
if (noNeedToWork) return 0;
return rest;
};
"#
);
// regression_6057_simple
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
)
},
regression_6057_simple,
r#"
const a = 'bar';
function foo(...a) {
return a;
}
"#
);
// parameters_regression_4333
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
block_scoping(unresolved_mark),
)
},
parameters_regression_4333,
r#"
const args = 'bar';
function foo(...args) {
return args;
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
destructuring(Default::default()),
)
},
issue_760,
"const initialState = 'foo'
export default function reducer(state = initialState, action = {}) {
}"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
)
},
rest_in_top_level_arrow_1,
"
const arrow = (...args) => {
console.log(args);
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
)
},
rest_in_top_level_arrow_2,
"
const arrow = () => (...args) => {
console.log(args);
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
)
},
rest_in_top_level_arrow_3,
"
const arrow = () => (...args) => {
console.log(this, args);
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
)
},
rest_in_top_level_arrow_4,
"
const arrow = () => (this, (...args) => {
console.log(this, args);
})
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
)
},
rest_in_top_level_arrow_nested_1,
"
const arrow = (...args) => (this, () => (...args) => {
console.log(this, args);
})
"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_2825,
"
const foo = (...rest) => console.log(this, rest)
const bar = () => this
"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_2811,
"
class Foo extends (function(){}) {
constructor(){
var foo = (...rest) => [rest, this];
if (true){
console.log(super(), foo());
} else {
super();
console.log(foo());
}
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
)
},
issue_3471,
"
class A {
a = 1 + ((...a) => a)
b = (...b) => b + this
static c = (c = 123) => c + this
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
)
},
issue_3569,
"
export class TableView extends React.Component {
constructor(props){
super(props);
this.getSearchForm = (innerWidth = 0)=>{
this.getProps();
};
}
}
"
);
test!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_complex_assign,
"function test({a: b} = {}) {}"
);
test!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_default_array_destructuring,
"function t([,,a] = [1,2,3]) { return a }"
);
test_exec!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_default_array_destructuring_exec,
"function t([,,a] = [1,2,3]) { return a }
expect(t()).toBe(3);
expect(t([4,5,6])).toBe(6);"
);
test_exec!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_default_earlier_params,
"function f(a, b = a, c = b) { return c; }
expect(f(3)).toBe(3);"
);
test_exec!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_default_iife_1128,
"const bar = true;
function foo(a = bar, ...b) {
const bar = false;
expect(b[0]).toBe(2);
expect(b[1]).toBe(3);
}
foo(1, 2, 3);"
);
test_exec!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_default_iife_4253,
"class Ref {
static nextId = 0
constructor(id = ++Ref.nextId, n = id) {
this.id = n
}
}
expect(new Ref().id).toBe(1);
expect(new Ref().id).toBe(2);"
);
test_exec!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_default_iife_self,
"class Ref {
constructor(ref = Ref) {
this.ref = ref
}
}
expect(new Ref().ref).toBe(Ref);"
);
test!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_default_multiple,
r#"
var t = function (e = "foo", f = 5) {
return e + " bar " + f;
};
var a = function (e, f = 5) {
return e + " bar " + f;
};"#
);
test_exec!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_object_destructuring,
"function required(msg) {
throw new Error(msg);
}
function sum(
{ arr = required('arr is required') } = { arr: arr = [] },
length = arr.length
) {
let i = 0;
let acc = 0;
for (let item of arr) {
if (i >= length) return acc;
acc += item;
i++;
}
return acc;
}
expect(sum({arr:[1,2]})).toBe(3);"
);
test!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_rest_mix,
r#"
function fn(
a1,
a2 = 4,
{a3, a4},
a5,
{a6, a7} = {}) {
}"#
);
test_exec!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_rest,
"const a = 1;
function rest(b = a, ...a) {
expect(b).toBe(1);
}
rest(undefined, 2)
function rest2(b = a, ...a) {
expect(a[0]).toBe(2);
}
rest2(undefined, 2)
function rest3(b = a, ...a) {
expect(a).toHaveLength(1);
}
rest3(undefined, 2)"
);
test!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_default_single,
r#"
var t = function (f = "foo") {
return f + " bar";
};"#
);
test!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_destructing_rest,
r#"
function t(x = "default", { a, b }, ...args) {
console.log(x, a, b, args);
}"#
);
test_exec!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
fn_len_overwrite_undefined,
"function t(undefined = 17, a = 3) {
return a;
}
expect(t()).toBe(3);"
);
test!(
syntax(),
|_| tr(Config {
ignore_function_length: true
}),
issue_5030,
r#"
let v0 = (Array, Int8Array, ...Int32Array) => (NaN + Infinity) * Int32Array.length;
console.log(v0(1, 2, 'hello', true, 7));
"#
);
#[testing::fixture("tests/parameters/**/input.js")]
fn fixture(input: PathBuf) {
let output = input.with_file_name("output.js");
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
(
resolver(unresolved_mark, Mark::new(), false),
parameters(Default::default(), unresolved_mark),
)
},
&input,
&output,
Default::default(),
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_shorthand_propertie.rs | Rust | use std::path::PathBuf;
use swc_common::Mark;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::es2015::shorthand;
use swc_ecma_transforms_testing::test_fixture;
#[testing::fixture("tests/shorthand_properties/**/input.js")]
fn fixture(input: PathBuf) {
let output = input.with_file_name("output.js");
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
(resolver(unresolved_mark, Mark::new(), false), shorthand())
},
&input,
&output,
Default::default(),
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_spread.rs | Rust | use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::es2015::{block_scoping, parameters, spread};
use swc_ecma_transforms_testing::{test, test_exec};
fn syntax() -> ::swc_ecma_parser::Syntax {
Default::default()
}
fn tr() -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
spread(Default::default()),
)
}
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
issue_270,
"instance[name](...args);"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
custom_call,
"ca(a, b, c, ...d, e)"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
custom_call_multi_spread,
"ca(a, b, ...d, e, f, ...h)"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
custom_call_noop,
"ca(a, b, c, d, e)"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
custom_array,
"[a, b, c, ...d, e]"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
custom_array_empty,
"[a,, b, c, ...d,,, e]"
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
custom_new_noop,
"new C(a, b, c, c, d, e)"
);
// this_context
test!(
syntax(),
|_| tr(),
this_context,
r#"
var obj = {
foo: function foo() {
this.bar(...arguments)
this.blah(...arguments)
}
}
"#
);
// arguments_array
test!(
syntax(),
|_| tr(),
arguments_array,
r#"
function foo() {
return bar([...arguments]);
}
function bar(one, two, three) {
return [one, two, three];
}
foo("foo", "bar");
"#
);
// single_exec
test_exec!(
syntax(),
|_| tr(),
single_exec,
r#"
// test that toConsumableArray clones the array.
const arr = [];
const foo = () => arr;
const x = [...foo()];
expect(x).not.toBe(arr);
"#
);
// arguments_concat
test!(
syntax(),
|_| tr(),
arguments_concat,
r#"
function foo() {
return bar("test", ...arguments);
}
function bar(one, two, three) {
return [one, two, three];
}
foo("foo", "bar");
"#
);
// contexted_method_call_super_multiple_args
test!(
syntax(),
|_| tr(),
contexted_method_call_super_multiple_args,
r#"
class Foo {
bar() {
super.bar(arg1, arg2, ...args);
}
}
"#
);
// array_literal_first
test!(
syntax(),
|_| tr(),
array_literal_first,
r#"
var lyrics = [...parts, "head", "and", "toes"];
"#
);
// regression_t6761
test!(
syntax(),
|_| tr(),
regression_t6761,
r#"
function fn(){}
var args = [1, 2, 3];
var obj = {obj: {fn}};
switch (true){
case true:
obj.obj.fn(...args);
break;
}
"#
);
// method_call_middle
test!(
syntax(),
|_| tr(),
method_call_middle,
r#"
add(foo, ...numbers, bar);
"#
);
// contexted_method_call_multiple_args
test!(
syntax(),
|_| tr(),
contexted_method_call_multiple_args,
r#"
foob.add(foo, bar, ...numbers);
foob.test.add(foo, bar, ...numbers);
"#
);
// contexted_computed_method_call_multiple_args
test!(
syntax(),
|_| tr(),
contexted_computed_method_call_multiple_args,
r#"
obj[method](foo, bar, ...args);
"#
);
// regression_6647
// method_call_multiple_args
test!(
syntax(),
|_| tr(),
method_call_multiple_args,
r#"
add(foo, bar, ...numbers);
"#
);
// array_literal_middle
test!(
syntax(),
|_| tr(),
array_literal_middle,
r#"
var a = [b, ...c, d];
"#
);
// array_literal_with_hole
test!(
syntax(),
|_| tr(),
array_literal_with_hole,
r#"
var arr = [ 'a',, 'b', ...c ];
"#
);
// regression_issue_8907
test!(
syntax(),
|_| tr(),
regression_issue_8907_modified,
r#"
const arr = [];
arr.concat = () => {
throw new Error('Should not be called');
};
const x = [...arr];
"#
);
// regression_issue_8907
test!(
// Cost is too high
ignore,
syntax(),
|_| tr(),
regression_issue_8907,
r#"
const arr = [];
arr.concat = () => {
throw new Error('Should not be called');
};
const x = [...arr];
"#
);
// method_call_multiple
test!(
syntax(),
|_| tr(),
method_call_multiple,
r#"
add(foo, ...numbers, bar, what, ...test);
"#
);
// arguments
test!(
syntax(),
|_| tr(),
arguments,
r#"
function foo() {
return bar(...arguments);
}
function bar(one, two, three) {
return [one, two, three];
}
foo("foo", "bar");
"#
);
// regression_issue_8907_exec
test_exec!(
syntax(),
|_| tr(),
regression_issue_8907_exec,
r#"
const arr = [];
arr.concat = () => {
throw new Error('Should not be called');
};
let x;
expect(() => {
x = [...arr];
}).not.toThrow();
expect(x).not.toBe(arr);
"#
);
// array_literal_multiple
test!(
syntax(),
|_| tr(),
array_literal_multiple,
r#"
var a = [b, ...c, d, e, ...f];
"#
);
// arguments_array_exec
test_exec!(
syntax(),
|_| tr(),
arguments_array_exec,
r#"
// test that toConsumableArray clones the array.
function foo() {
const x = [...arguments];
expect(x).not.toBe(arguments);
}
foo(1,2);
"#
);
// array_literals
test!(
syntax(),
|_| tr(),
array_literals,
r#"
var lyrics = ["head", "and", "toes", ...parts];
"#
);
// regression
// spread_new_expression
test!(
syntax(),
|_| tr(),
spread_new_expression,
r#"
new Numbers(...nums);
new Numbers(1, ...nums);
"#
);
// spread_array_literal_with_hole
test!(
syntax(),
|_| tr(),
spread_array_literal_with_hole,
r#"
var arr = [ 'a',, 'b', ...c ];
"#
);
// spread_single
test_exec!(
syntax(),
|_| tr(),
spread_single_exec,
r#"
// test that toConsumableArray clones the array.
const arr = [];
const foo = () => arr;
const x = [...foo()];
expect(x).not.toBe(arr);
"#
);
// spread_contexted_method_call_multiple_args
test!(
syntax(),
|_| tr(),
spread_contexted_method_call_multiple_args,
r#"
foob.add(foo, bar, ...numbers);
foob.test.add(foo, bar, ...numbers);
"#
);
// spread_method_call_array_literal
test!(
syntax(),
|_| tr(),
spread_method_call_array_literal,
r#"
f(...[1, 2, 3]);
"#
);
// spread_method_call_single_arg
test!(
syntax(),
|_| tr(),
spread_method_call_single_arg,
r#"
add(...numbers);
"#
);
// spread_known_rest
test!(
// Cost is too high.
ignore,
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
parameters(Default::default(), unresolved_mark),
spread(Default::default()),
block_scoping(unresolved_mark),
)
},
spread_known_rest,
r#"
function foo(...bar) {
return [...bar];
}
"#
);
// spread_method_call_middle
test!(
syntax(),
|_| tr(),
spread_method_call_middle,
r#"
add(foo, ...numbers, bar);
"#
);
// spread_method_call_first
test!(
syntax(),
|_| tr(),
spread_method_call_first,
r#"
add(...numbers, foo, bar);
"#
);
// spread_contexted_method_call_super_single_arg
test!(
syntax(),
|_| tr(),
spread_contexted_method_call_super_single_arg,
r#"
class Foo {
bar() {
super.bar(...args);
}
}
"#
);
// spread_contexted_method_call_single_arg
test!(
syntax(),
|_| tr(),
spread_contexted_method_call_single_arg,
r#"
foob.add(...numbers);
foob.test.add(...numbers);
"#
);
// spread_array_literal_middle
test!(
syntax(),
|_| tr(),
spread_array_literal_middle,
r#"
var a = [b, ...c, d];
"#
);
// spread_array_literals
test!(
syntax(),
|_| tr(),
spread_array_literals,
r#"
var lyrics = ["head", "and", "toes", ...parts];
"#
);
// regression_10416
test!(
syntax(),
|_| tr(),
regression_10416,
r#"
const E_ARR = [];
export default function () {
const someVar = E_ARR;
return [...someVar];
}
"#
);
// spread_method_call_multiple
test!(
syntax(),
|_| tr(),
spread_method_call_multiple,
r#"
add(foo, ...numbers, bar, what, ...test);
"#
);
// spread_arguments
test!(
syntax(),
|_| tr(),
spread_arguments,
r#"
function foo() {
return bar(...arguments);
}
function bar(one, two, three) {
return [one, two, three];
}
foo("foo", "bar");
"#
);
// spread_contexted_method_call_super_multiple_args
test!(
syntax(),
|_| tr(),
spread_contexted_method_call_super_multiple_args,
r#"
class Foo {
bar() {
super.bar(arg1, arg2, ...args);
}
}
"#
);
// spread_contexted_computed_method_call_single_arg
test!(
syntax(),
|_| tr(),
spread_contexted_computed_method_call_single_arg,
r#"
obj[method](...args);
"#
);
// spread_arguments_concat
test!(
syntax(),
|_| tr(),
spread_arguments_concat,
r#"
function foo() {
return bar("test", ...arguments);
}
function bar(one, two, three) {
return [one, two, three];
}
foo("foo", "bar");
"#
);
test!(
syntax(),
|_| tr(),
spread_string_literial,
"
String.raw({ raw: 'abcd' }, ...'___');
"
);
test!(
syntax(),
|_| tr(),
spread_string_literial_2,
"
f({ x: 0 }, ...[1, 2], [3], ...'456');
"
);
test!(
syntax(),
|_| tr(),
spread_literial,
r#"
f(1, ...[2, 3], ...[...[4, 5]], ...[6, ...[7]]);
f(1, ..."123", ...[..."456", ..."789"]);
"#
);
test!(
syntax(),
|_| tr(),
spread_literial_init_hole,
r#"
f(1, ...[2, , 3], ...[...[4, ,]]);
f(...[2, , 3], ...[...[4, ,]]);
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2015_template_literals.rs | Rust | use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_compat::es2015::template_literal;
use swc_ecma_transforms_testing::{test, test_exec};
fn syntax() -> Syntax {
Default::default()
}
fn tr(config: template_literal::Config) -> impl Pass {
template_literal(config)
}
test_exec!(
syntax(),
|_| tr(Default::default()),
issue_231,
"const truthy = 'a=b';
const foo = `http://example.com/foo/bar${truthy && '?'}${truthy}`;
expect(foo).toBe('http://example.com/foo/bar?a=b');\
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
issue_388,
"
\"use strict\";
const write = (text) => {
console.log(text)
}
write(1)
write('2')
write`3`"
);
test!(
syntax(),
|_| tr(Default::default()),
escape_quotes,
r#"var t = `'${foo}' "${bar}"`;"#
);
test!(
syntax(),
|_| tr(Default::default()),
multiple,
r#"var foo = `test ${foo} ${bar}`;"#
);
test!(
syntax(),
|_| tr(Default::default()),
none,
r#"var foo = `test`;"#
);
test!(
syntax(),
|_| tr(Default::default()),
only,
r#"var foo = `${test}`;"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
order,
r#"
const calls = [];
`
${
(calls.push(1), {
[Symbol.toPrimitive](){
calls.push(2);
return 'foo';
}
})
}
${
(calls.push(3), {
[Symbol.toPrimitive](){
calls.push(4);
return 'bar';
}
})
}
`;
expect(calls).toEqual([1, 2, 3, 4]);"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
order2,
r#"const calls = [];
`
${{
[Symbol.toPrimitive]() {
calls.push(1);
return "foo";
}
}}
${1 +
{
valueOf() {
calls.push(2);
return 2;
}
}}
`;
expect(calls).toEqual([1, 2]);"#
);
test!(
syntax(),
|_| tr(Default::default()),
single,
r#"var foo = `test ${foo}`;"#
);
test!(
syntax(),
|_| tr(Default::default()),
statement,
r#"var foo = `test ${foo + bar}`;"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
symbol,
r#"const fn = () => `${Symbol()}`;
expect(fn).toThrow(TypeError);"#
);
test!(
syntax(),
|_| tr(Default::default()),
template_revision,
r"tag`\unicode and \u{55}`;
tag`\01`;
tag`\xg${0}right`;
tag`left${0}\xg`;
tag`left${0}\xg${1}right`;
tag`left${0}\u000g${1}right`;
tag`left${0}\u{-0}${1}right`;
function a() {
var undefined = 4;
tag`\01`;
}"
);
// default_order_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
default_order_exec,
r#"
const calls = [];
`
${
(calls.push(1), {
[Symbol.toPrimitive](){
calls.push(2);
return 'foo';
}
})
}
${
(calls.push(3), {
[Symbol.toPrimitive](){
calls.push(4);
return 'bar';
}
})
}
`;
expect(calls).toEqual([1, 2, 3, 4]);
"#
);
// default_only
test!(
syntax(),
|_| tr(Default::default()),
default_only,
r#"
var foo = `${test}`;
"#
);
// default_single
test!(
syntax(),
|_| tr(Default::default()),
default_single,
r#"
var foo = `test ${foo}`;
"#
);
// default_statement
test!(
syntax(),
|_| tr(Default::default()),
default_statement,
r#"
var foo = `test ${foo + bar}`;
"#
);
// default_expression_first
test!(
syntax(),
|_| tr(Default::default()),
default_expression_first,
r#"
var foo = 5;
var bar = 10;
var baz = 15;
var example = `${"a"}`;
var example2 = `${1}`;
var example3 = 1 + `${foo}${bar}${baz}`;
var example4 = 1 + `${foo}bar${baz}`;
var example5 = `${""}`;
"#
);
// default_literals
test!(
syntax(),
|_| tr(Default::default()),
default_literals,
r#"
var foo = `${1}${f}oo${true}${b}ar${0}${baz}`;
"#
);
// default_multiline
test!(
syntax(),
|_| tr(Default::default()),
default_multiline,
r#"
var o = `wow
this is
actually multiline!`;
"#
);
// default_template_revision
test!(
// TODO: Improve parser
ignore,
syntax(),
|_| tr(Default::default()),
default_template_revision,
r"
tag`\unicode and \u{55}`;
tag`\01`;
tag`\xg${0}right`;
tag`left${0}\xg`;
tag`left${0}\xg${1}right`;
tag`left${0}\u000g${1}right`;
tag`left${0}\u{-0}${1}right`;
function a() {
var undefined = 4;
tag`\01`;
}
"
);
// default_order2_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
default_order2_exec,
r#"
const calls = [];
`
${{
[Symbol.toPrimitive]() {
calls.push(1);
return "foo";
}
}}
${1 +
{
valueOf() {
calls.push(2);
return 2;
}
}}
`;
expect(calls).toEqual([1, 2]);
"#
);
// default_cache_revision_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
default_cache_revision_exec,
r#"
var tag = v => v;
function foo() {
return tag`some template`;
}
function bar() {
return tag`some template`;
}
expect(foo()).toBe(foo());
expect(foo()).toEqual(["some template"]);
expect(bar()).toBe(bar());
expect(bar()).toEqual(["some template"]);
expect(bar()).not.toBe(foo());
"#
);
// default_functions
test!(
syntax(),
|_| tr(Default::default()),
default_functions,
r#"
var foo = `test ${_.test(foo)} ${bar}`;
"#
);
// default_none
test!(
syntax(),
|_| tr(Default::default()),
default_none,
r#"
var foo = `test`;
"#
);
// default_symbol_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
default_symbol_exec,
r#"
const fn = () => `${Symbol()}`;
expect(fn).toThrow(TypeError);
"#
);
// default_cache_revision
test!(
syntax(),
|_| tr(Default::default()),
default_cache_revision,
r#"
var tag = v => v;
function foo() {
return tag`some template`;
}
function bar() {
return tag`some template`;
}
expect(foo()).toBe(foo());
expect(foo()).toEqual(["some template"]);
expect(bar()).toBe(bar());
expect(bar()).toEqual(["some template"]);
expect(bar()).not.toBe(foo());
"#
);
// default_tag
test!(
syntax(),
|_| tr(Default::default()),
default_tag,
r"
var foo = bar`wow\na${ 42 }b ${_.foobar()}`;
var bar = bar`wow\nab${ 42 } ${_.foobar()}`;
var bar = bar`wow\naB${ 42 } ${_.baz()}`;
"
);
// default_simple_tag
test!(
syntax(),
|_| tr(Default::default()),
default_simple_tag,
r#"
var foo = tag`wow`;
var bar = tag`first${1}second`;
"#
);
test!(
syntax(),
|_| tr(Default::default()),
issue_598_1,
"
export function foo() {
console.log(i18n`Hello World`);
console.log(i18n`Nobody will ever see this.`);
}
"
);
test!(syntax(), |_| tr(Default::default()), codegen_01, "`\"`");
test!(syntax(), |_| tr(Default::default()), codegen_02, "`\"\"`");
test!(
syntax(),
|_| tr(Default::default()),
codegen_03,
"`\"${foo}`"
);
test!(
syntax(),
|_| tr(Default::default()),
codegen_04,
"`\"${foo}\"`"
);
test!(
syntax(),
|_| tr(Default::default()),
codegen_05,
"`\"\"${foo}\"\"`"
);
test!(syntax(), |_| tr(Default::default()), codegen_06, "\"``\"");
test!(
syntax(),
|_| tr(Default::default()),
codegen_07,
r#"`The ${argumentName} has unexpected type of "`"#
);
test!(
syntax(),
|_| tr(Default::default()),
codegen_08,
r#"`". Expected argument to be an object with the following `"#
);
test!(
syntax(),
|_| tr(Default::default()),
codegen_09,
r#"`keys: "${reducerKeys.join('" "')}"`"#
);
test!(
syntax(),
|_| tr(Default::default()),
codegen_10,
r#"`The ${argumentName} has unexpected type of "` +
matchType +
`". Expected argument to be an object with the following ` +
`keys: "${reducerKeys.join('" "')}"`"#
);
test!(
syntax(),
|_| tr(Default::default()),
issue_1280,
"
const myVar = T`'Hello'`;
"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_1488_1,
"
`\\``
"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_1549_1,
"const a = `\r\n`;"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_1549_2,
"const a = \"\\r\\n\";"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_1742_1,
"
function foo() {
return this;
}
foo`template`
"
);
test_exec!(
syntax(),
|_| tr(Default::default()),
issue_1742_2,
"
const obj = {
foo() {
return this;
}
}
expect(typeof obj.foo`template`).toEqual('object')
"
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_escape_quotes,
r#"var t = `'${foo}' "${bar}"`;"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_expression_first,
r#"
var foo = 5;
var bar = 10;
var baz = 15;
var example = `${"a"}`;
var example2 = `${1}`;
var example3 = 1 + `${foo}${bar}${baz}`;
var example4 = 1 + `${foo}bar${baz}`;
var example5 = `${""}`;"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_function,
r#"var foo = `test ${_.test(foo)} ${bar}`;"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_literals,
r#"var foo = `${1}${f}oo${true}${b}ar${0}${baz}`;"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_multi_line,
r#"
var o = `wow
this is
actually multiline!`;
"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_multiple,
r#"var foo = `test ${foo} ${bar}`;"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_none,
r#"var foo = `test`;"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_only,
r#"var foo = `${test}`;"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_single,
r#"var foo = `test ${foo}`;"#
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_statement,
r#"var foo = `test ${foo + bar}`;"#
);
test_exec!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_order,
"
const calls = [];
`
${
calls.push(1),
{
[Symbol.toPrimitive](){
calls.push(2);
return 'foo';
}
}
}
${
calls.push(3),
{
[Symbol.toPrimitive](){
calls.push(4);
return 'bar';
}
}
}
`;
expect(calls).toEqual([1, 2, 3, 4]);
"
);
test_exec!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_order_2,
"
const calls = [];
`
${{
[Symbol.toPrimitive]() {
calls.push(1);
return 'foo';
}
}}
${1 +
{
valueOf() {
calls.push(2);
return 2;
}
}}
`;
expect(calls).toEqual([1, 2]);
"
);
test_exec!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: true,
mutable_template: false
}),
loose_symbol,
"const fn = () => `${Symbol()}`;
expect(fn).toThrow(TypeError);"
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: false,
mutable_template: true
}),
loose_no_tag,
"`foo ${bar} baz`;"
);
test!(
syntax(),
|_| tr(template_literal::Config {
ignore_to_primitive: false,
mutable_template: true
}),
loose_tag,
r"
var foo = bar`wow\na${ 42 }b ${_.foobar()}`;
var bar = bar`wow\nab${ 42 } ${_.foobar()}`;
var bar = bar`wow\naB${ 42 } ${_.baz()}`;
"
);
test!(
// TODO: Fix parser
ignore,
syntax(),
|_| tr(Default::default()),
loose_template_revision,
r"tag`\unicode and \u{55}`;
tag`\01`;
tag`\xg${0}right`;
tag`left${0}\xg`;
tag`left${0}\xg${1}right`;
tag`left${0}\u000g${1}right`;
tag`left${0}\u{-0}${1}right`;
function a() {
var undefined = 4;
tag`\01`;
}"
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2017_async_to_generator.rs | Rust | use std::{fs::read_to_string, path::PathBuf};
use swc_common::{Mark, Spanned};
use swc_ecma_ast::*;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::{fixer::fixer, resolver};
use swc_ecma_transforms_compat::{
es2015,
es2015::{
arrow, block_scoping, destructuring, function_name, generator::generator, parameters,
},
es2017::async_to_generator,
es2022::class_properties,
};
use swc_ecma_transforms_testing::{compare_stdout, test, test_exec};
use swc_ecma_visit::{fold_pass, Fold, FoldWith};
struct ParenRemover;
impl Fold for ParenRemover {
fn fold_expr(&mut self, expr: Expr) -> Expr {
let expr = expr;
let span = expr.span();
let expr = expr.fold_children_with(self);
match expr {
Expr::Paren(ParenExpr { expr, .. }) => match *expr {
Expr::Member(e) => MemberExpr { span, ..e }.into(),
Expr::New(e) => NewExpr { span, ..e }.into(),
_ => *expr,
},
_ => expr,
}
}
}
fn syntax() -> Syntax {
Syntax::default()
}
fn tr() -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
fold_pass(ParenRemover),
arrow(unresolved_mark),
parameters(Default::default(), unresolved_mark),
destructuring(destructuring::Config { loose: false }),
function_name(),
async_to_generator(Default::default(), unresolved_mark),
fixer(None),
)
}
fn with_resolver() -> impl Pass {
let unresolved = Mark::new();
let top_level = Mark::new();
(
resolver(unresolved, top_level, false),
async_to_generator(Default::default(), unresolved),
)
}
test!(
syntax(),
|_| tr(),
issue_216,
r#"
async function foo(bar) {
bar && await bar();
}
"#
);
test!(
syntax(),
|_| tr(),
async_arrow_in_method,
r#"
let TestClass = {
name: "John Doe",
testMethodFailure() {
return new Promise(async (resolve) => {
console.log(this);
setTimeout(resolve, 1000);
});
}
};
"#
);
test!(
syntax(),
|_| tr(),
async_default_arguments,
r#"
function mandatory(paramName) {
throw new Error(`Missing parameter: ${paramName}`);
}
async function foo({ a, b = mandatory("b") }) {
return Promise.resolve(b);
}
"#
);
test!(
syntax(),
|_| tr(),
async_iife,
r#"
(async function() { await 'ok' })();
(async () => { await 'ok' })();
(async function notIIFE() { await 'ok' });
(async () => { await 'not iife' });
"#
);
test!(
syntax(),
|_| tr(),
r#async,
r#"
class Foo {
async foo() {
var wat = await bar();
}
}
"#
);
test!(
syntax(),
|_| tr(),
deeply_nested_asyncs,
r#"
async function s(x, ...args) {
let t = async (y, a) => {
let r = async (z, b, ...innerArgs) => {
await z;
console.log(this, innerArgs, arguments);
return this.x;
}
await r();
console.log(this, args, arguments);
return this.g(r);
}
await t();
return this.h(t);
}
"#
);
test!(
syntax(),
|_| tr(),
expression,
r#"
var foo = async function () {
var wat = await bar();
};
var foo2 = async function () {
var wat = await bar();
},
bar = async function () {
var wat = await foo();
};
"#
);
test!(
syntax(),
|_| tr(),
named_expression,
r#"
var foo = async function bar() {
console.log(bar);
};
"#
);
test!(
syntax(),
|_| tr(),
no_parameters_and_no_id,
r#"
foo(async function () {
});"#
);
test!(
syntax(),
|_| tr(),
object_method_with_arrows,
r#"
class Class {
async method() {
this;
() => this;
() => {
this;
() => this;
function x() {
this;
() => {this}
async () => {this}
}
}
function x() {
this;
() => {this}
async () => {this}
}
}
}
"#
);
test!(
syntax(),
|_| tr(),
object_method_with_super,
r#"class Foo extends class {} {
async method() {
super.method();
var arrow = () => super.method();
}
}"#
);
test_exec!(
syntax(),
|_| tr(),
class_method_this,
r#"
class Foo {
async foo() {
this.x = 1;
return () => this;
}
}
let foo = new Foo();
return foo.foo().then(cur => {
expect(cur().x).toBe(1);
});
"#
);
test_exec!(
syntax(),
|_| tr(),
class_method_super,
r#"
class Foo {
async foo() {
this.x = 1;
return () => this;
}
}
class Bar extends Foo {
async bar() {
return await super.foo();
}
}
let bar = new Bar();
return bar.bar().then(cur => {
expect(cur().x).toBe(1);
});
"#
);
test_exec!(
syntax(),
|_| tr(),
class_getter_super,
r#"
let called = false;
class Foo {
get foo() {
called = true;
return 1
}
}
class Bar extends Foo {
async bar() {
return super.foo;
}
}
let bar = new Bar();
return bar.bar().then(foo => {
expect(called).toBe(true);
expect(foo).toBe(1);
});
"#
);
test_exec!(
syntax(),
|_| tr(),
class_setter_super,
r#"
let called = false;
class Foo {
set foo(v) {
this.v = v;
called = true;
}
}
class Bar extends Foo {
async bar() {
super.foo = 1;
return this;
}
}
let bar = new Bar();
return bar.bar().then(bar => {
expect(called).toBe(true);
expect(bar.v).toBe(1);
});
"#
);
test_exec!(
syntax(),
|_| tr(),
class_method_this_complex,
r#"
class Class {
async method() {
console.log(this);
expect(this.x).toBe(1);
(() => expect(this.x).toBe(1))();
(() => {
expect(this.x).toBe(1);
(() => expect(this.x).toBe(1))();
function x() {
this;
() => {this}
async () => {this}
}
})()
function x() {
this;
() => {this}
async () => {this}
}
}
}
let c = new Class();
c.x = 1;
return c.method();
"#
);
test!(
syntax(),
|_| tr(),
object_method,
r#"
let obj = {
a: 123,
async foo(bar) {
return await baz(bar);
}
}"#
);
test!(
syntax(),
|_| tr(),
babel_parameters,
r#"
async function foo(bar) {
}
"#
);
test!(
syntax(),
|_| tr(),
statement,
r#"
async function foo() {
var wat = await bar();
}
"#
);
test!(
syntax(),
|_| tr(),
issue_319,
"export default obj({
async f() {
await g();
}
});"
);
test_exec!(
syntax(),
|t| (
tr(),
es2015(
Mark::fresh(Mark::root()),
Some(t.comments.clone()),
Default::default()
)
),
issue_400_1,
"class A {
constructor() {
this.a_num = 10;
}
async print() {
expect(this.a_num).toBe(10);
}
}
class B extends A {
constructor(num) {
super();
this.b_num = num;
}
async print() {
expect(this.b_num).toBe(20);
await super.print();
}
}
return (new B(20)).print().then(() => console.log('Done'));"
);
test_exec!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_400_2,
"class A {
constructor() {
this.a_num = 10;
}
async print() {
expect(this.a_num).toBe(10);
}
}
class B extends A {
constructor(num) {
super();
this.b_num = num;
}
async print() {
expect(this.b_num).toBe(20);
await super.print();
}
}
return (new B(20)).print().then(() => console.log('Done'));"
);
test_exec!(
syntax(),
|t| {
let unresolved_mark = Mark::new();
(
async_to_generator(Default::default(), unresolved_mark),
es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
issue_400_3,
"class A {
constructor() {
this.a_num = 10;
}
async print() {
expect(this.a_num).toBe(10);
}
}
return (new A()).print();"
);
//// regression_7178
//test!(
// syntax(),
// |_| (jsx(), jsc_constant_elements(),
// async_to_generator(Default::default()),), regression_7178,
// r#"
//const title = "Neem contact op";
//
//async function action() {
// return <Contact title={title} />;
//}
//
//"#
// r#"
//const title = "Neem contact op";
//
//function action() {
// return _action.apply(this, arguments);
//}
//
//var _ref =
// /*#__PURE__*/
//React.createElement(Contact, {
// title: title
//});
//
//function _action() {
// _action = _async_to_generator(function* () {
// return _ref;
// });
// return _action.apply(this, arguments);
//}
//
//"#
//);
// bluebird_coroutines_named_expression
test!(
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
bluebird_coroutines_named_expression,
r#"
var foo = async function bar() {
console.log(bar);
};
"#
);
// export_async_lone_export
test!(
// TODO: Enable this test after implementing es6 module pass.
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
export_async_lone_export,
r#"
export async function foo () { }
"#
);
// bluebird_coroutines_arrow_function
test!(
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
bluebird_coroutines_arrow_function,
r#"
(async () => { await foo(); })()
"#
);
// regression_t6882
// regression_t7194
test!(
// Optimization
syntax(),
|_| {
let unresolved_mark = Mark::new();
(
async_to_generator(Default::default(), unresolved_mark),
arrow(unresolved_mark),
)
},
regression_t7194,
r#"
function f() {
g(async function() {
c(() => this);
});
}
(async function () {
console.log('async wrapper:', this === 'foo')
;(() => {
console.log('nested arrow:', this === 'foo')
})()
}).call('foo')
"#
);
// async_to_generator_shadowed_promise
test!(
// TODO: Unignore this
ignore,
syntax(),
|_| with_resolver(),
async_to_generator_shadowed_promise,
r#"
let Promise;
async function foo() {
await new Promise(resolve => { resolve() });
}
"#
);
// async_to_generator_object_method_with_arrows
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_object_method_with_arrows,
r#"
class Class {
async method() {
this;
() => this;
() => {
this;
() => this;
function x() {
this;
() => {this}
async () => {this}
}
}
function x() {
this;
() => {this}
async () => {this}
}
}
}
"#
);
// async_to_generator_object_method
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_object_method,
r#"
let obj = {
a: 123,
async foo(bar) {
return await baz(bar);
}
}
"#
);
// bluebird_coroutines_class
test!(
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
bluebird_coroutines_class,
r#"
class Foo {
async foo() {
var wat = await bar();
}
}
"#
);
// async_to_generator_async_iife_with_regenerator
test!(
ignore,
syntax(),
|_| {
let unresolved_mark = Mark::new();
(
async_to_generator(Default::default(), unresolved_mark),
//regenerator(),
arrow(unresolved_mark),
)
},
async_to_generator_async_iife_with_regenerator,
r#"
(async function() { await 'ok' })();
(async () => { await 'ok' })();
(async function notIIFE() { await 'ok' });
(async () => { await 'not iife' });
"#
);
//// regression_gh_6923
//test!(syntax(),|_| tr("{
// "presets": [
// [
// "env"
// {
// "targets": {
// "chrome": "62"
// "edge": "15"
// "firefox": "52"
// "safari": "11"
// }
// }
// ]
// ]
//}
//"), regression_gh_6923, r#"
//async function foo() {
// (async function (number) {
// const tmp = number
// })
//}
//"# r#"
//function foo() {
// return _foo.apply(this, arguments);
//}
//
//function _foo() {
// _foo = _async_to_generator(
// /*#__PURE__*/
// regeneratorRuntime.mark(function _callee2() {
// return regeneratorRuntime.wrap(function _callee2$(_context2) {
// while (1) switch (_context2.prev = _context2.next) {
// case 0:
// /*#__PURE__*/
// (function () {
// var _ref = _async_to_generator(
// /*#__PURE__*/
// regeneratorRuntime.mark(function _callee(number) {
// var tmp;
// return regeneratorRuntime.wrap(function _callee$(_context) {
// while (1) switch (_context.prev = _context.next) {
// case 0:
// tmp = number;
//
// case 1:
// case "end":
// return _context.stop();
// }
// }, _callee);
// }));
//
// return function (_x) {
// return _ref.apply(this, arguments);
// };
// })();
//
// case 1:
// case "end":
// return _context2.stop();
// }
// }, _callee2);
// }));
// return _foo.apply(this, arguments);
//}
//
//"#);
// async_to_generator_named_expression
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_named_expression,
r#"
var foo = async function bar() {
console.log(bar);
};
"#
);
//// async_to_generator_async_iife_with_regenerator_spec
//test!(
// syntax(),
// |_| (async_to_generator(Default::default()), arrow(),
// regenerator(),), async_to_generator_async_iife_with_regenerator_spec,
// r#"
//(async function() { await 'ok' })();
//(async () => { await 'ok' })();
//(async function notIIFE() { await 'ok' });
//(async () => { await 'not iife' });
//
//"#
// r#"
//var _this = this;
//
//_async_to_generator(
// /*#__PURE__*/
//regeneratorRuntime.mark(function _callee() {
// return regeneratorRuntime.wrap(function _callee$(_context) {
// while (1) switch (_context.prev = _context.next) {
// case 0:
// _context.next = 2;
// return 'ok';
//
// case 2:
// case "end":
// return _context.stop();
// }
// }, _callee);
//}))();
//_async_to_generator(
// /*#__PURE__*/
//regeneratorRuntime.mark(function _callee2() {
// return regeneratorRuntime.wrap(function _callee2$(_context2) {
// while (1) switch (_context2.prev = _context2.next) {
// case 0:
// _new_arrow_check(this, _this);
// _context2.next = 3;
// return 'ok';
//
// case 3:
// case "end":
// return _context2.stop();
// }
// }, _callee2, this);
//})).bind(this)();
//
// /*#__PURE__*/
//(function () {
// var _notIIFE = _async_to_generator(
// /*#__PURE__*/
// regeneratorRuntime.mark(function _callee3() {
// return regeneratorRuntime.wrap(function _callee3$(_context3) {
// while (1) switch (_context3.prev = _context3.next) {
// case 0:
// _context3.next = 2;
// return 'ok';
//
// case 2:
// case "end":
// return _context3.stop();
// }
// }, _callee3);
// }));
//
// function notIIFE() {
// return _notIIFE.apply(this, arguments);
// }
//
// return notIIFE;
//})();
//
// /*#__PURE__*/
//_async_to_generator(
// /*#__PURE__*/
//regeneratorRuntime.mark(function _callee4() {
// return regeneratorRuntime.wrap(function _callee4$(_context4) {
// while (1) switch (_context4.prev = _context4.next) {
// case 0:
// _new_arrow_check(this, _this);
// _context4.next = 3;
// return 'not iife';
//
// case 3:
// case "end":
// return _context4.stop();
// }
// }, _callee4, this);
//})).bind(this);
//
//"#
//);
// async_to_generator_async_arrow_in_method
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_async_arrow_in_method,
r#"
let TestClass = {
name: "John Doe",
testMethodFailure() {
return new Promise(async (resolve) => {
console.log(this);
setTimeout(resolve, 1000);
});
}
};
"#
);
// bluebird_coroutines_statement
test!(
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
bluebird_coroutines_statement,
r#"
async function foo() {
var wat = await bar();
}
"#
);
// regression_4943
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
async_to_generator(Default::default(), unresolved_mark),
parameters(Default::default(), unresolved_mark),
destructuring(destructuring::Config { loose: false }),
)
},
regression_4943,
r#"
"use strict";
function mandatory(paramName) {
throw new Error(`Missing parameter: ${paramName}`);
}
async function foo({ a, b = mandatory("b") }) {
return Promise.resolve(b);
}
"#
);
// export_async_default_arrow_export
test!(
// TODO: Enable this test after implementing es6 module pass.
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
export_async_default_arrow_export,
r#"
export default async () => { return await foo(); }
"#
);
// async_to_generator_function_arity
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_function_arity,
r#"
async function one(a, b = 1) {}
async function two(a, b, ...c) {}
async function three(a, b = 1, c, d = 3) {}
async function four(a, b = 1, c, ...d) {}
async function five(a, {b}){}
async function six(a, {b} = {}){}
"#
);
// async_to_generator_object_method_with_super
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_object_method_with_super_caching,
r#"
class Foo extends class {} {
async method() {
super.method();
var arrow = () => super.method();
}
}
"#
);
// export_async_default_export
test!(
// TODO: Enable this test after implementing es6 module pass.
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
export_async_default_export,
r#"
export default async function myFunc() {}
"#
);
// async_to_generator_async
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_async,
r#"
class Foo {
async foo() {
var wat = await bar();
}
}
"#
);
// regression_8783
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
regression_8783,
r#"
(async function poll() {
console.log(await Promise.resolve('Hello'))
setTimeout(poll, 1000);
})();
"#
);
// async_to_generator_deeply_nested_asyncs
test!(
syntax(),
|_| with_resolver(),
async_to_generator_deeply_nested_asyncs,
r#"
async function s(x, ...args) {
let t = async (y, a) => {
let r = async (z, b, ...innerArgs) => {
await z;
console.log(this, innerArgs, arguments);
return this.x;
}
await r();
console.log(this, args, arguments);
return this.g(r);
}
await t();
return this.h(t);
}
"#
);
// export_async_import_and_export
test!(
// TODO: Enable this test after implementing es6 module pass.
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
export_async_import_and_export,
r#"
import bar from 'bar';
export async function foo () { }
"#
);
// async_to_generator_shadowed_promise_nested
test!(
// TODO: Unignore this
ignore,
syntax(),
|_| with_resolver(),
async_to_generator_shadowed_promise_nested,
r#"
let Promise;
async function foo() {
let Promise;
await bar();
async function bar() {
return Promise.resolve();
}
}
"#
);
// bluebird_coroutines
// export_async
// regression_4599
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
regression_4599,
r#"
async () => await promise
async () => { await promise }
"#
);
// regression_4943_exec
test_exec!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
regression_4943_exec,
r#"
"use strict";
function mandatory(paramName) {
throw new Error(`Missing parameter: ${paramName}`);
}
async function foo({ a, b = mandatory("b") } = {}) {
return Promise.resolve(b);
}
return foo().then(() => {
throw new Error('should not occur');
}, () => true);
"#
);
// regression_8783_exec
test_exec!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
regression_8783_exec,
r#"
let log = [];
let resolve;
const main = new Promise(r => { resolve = r });
(async function poll(count) {
log.push(await Promise.resolve(count))
if (count < 3) setTimeout(poll, 10, count + 1);
else resolve();
})(0)
return main.then(() => {
expect(log).toEqual([0, 1, 2, 3]);
});
"#
);
// bluebird_coroutines_expression
test!(
ignore,
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
bluebird_coroutines_expression,
r#"
var foo = async function () {
var wat = await bar();
};
"#
);
// async_to_generator_expression
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_expression,
r#"
var foo = async function () {
var wat = await bar();
};
var foo2 = async function () {
var wat = await bar();
},
bar = async function () {
var wat = await foo();
};
"#
);
// async_to_generator_statement
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_statement,
r#"
async function foo() {
var wat = await bar();
}
"#
);
// async_to_generator_shadowed_promise_import
test!(
// TODO: Unignore this
ignore,
syntax(),
|_| with_resolver(),
async_to_generator_shadowed_promise_import,
r#"
import Promise from 'somewhere';
async function foo() {
await Promise.resolve();
}
"#
);
// async_to_generator_parameters
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
async_to_generator_parameters,
r#"
async function foo(bar) {
}
"#
);
// async_to_generator
// regression_t6882_exec
test_exec!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
regression_t6882_exec,
r#"
foo();
async function foo() {}
"#
);
// async_to_generator_parameters
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_600,
r#"
async function foo() {
for (let a of b) {
}
}
"#
);
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1036_1,
"
const x = async function() {
console.log(
await Promise.all([[1], [2], [3]].map(
async ([a]) => Promise.resolve().then(() => a * 2))
)
);
}
"
);
test_exec!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1036_2,
"
const x = async function() {
return await Promise.all([[1], [2], [3]].map(
async ([a]) => Promise.resolve().then(() => a * 2))
)
};
return x().then(x => {
expect(x).toEqual([2, 4, 6])
})
"
);
test!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1216_1,
"
const source = Math.random() < 2 ? 'matilda' : 'fred';
const details = {
_id: '1',
};
async function request(path) {
return `success:${path}`;
}
(async function () {
const obj = source === 'matilda'
? details
: await request(
`/${details._id}?source=${source}`
);
console.log({ obj });
})();
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1125_1,
"
async function test() {
try {
await 1
} finally {
console.log(2)
}
}
test()
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1341_1,
"
class A {
val = '1';
async foo() {
try {
return await (async (x) => x + this.val)('a');
} catch (e) {
throw e;
}
}
}
"
);
test_exec!(
Syntax::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), Mark::new()),
)
},
issue_1341_1_exec,
"
class A {
val = '1';
async foo() {
try {
return await (async (x) => x + this.val)('a');
} catch (e) {
throw e;
}
}
}
const a = new A();
expect(a.foo()).resolves.toEqual('a1')
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1341_2,
"
class A {
val = '1';
async foo() {
return await (async (x) => x + this.val)('a');
}
}
"
);
test_exec!(
Syntax::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), Mark::new()),
)
},
issue_1341_2_exec,
"
class A {
val = '1';
async foo() {
return await (async (x) => x + this.val)('a');
}
}
const a = new A();
expect(a.foo()).resolves.toEqual('a1')
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1455_1,
"
const obj = {
find({ platform }) {
return { platform }
},
byPlatform: async function (platform) {
const result = await this.find({ platform: { $eq: platform } });
return result;
},
};
obj.byPlatform('foo').then(v => console.log(v))
"
);
test_exec!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1575_1,
"
const obj = {
foo: 5,
async method() {
return this.foo;
}
}
return obj.method().then((res) => expect(res).toBe(5))
"
);
test_exec!(
Syntax::default(),
|t| {
let mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), mark),
generator(mark, t.comments.clone()),
)
},
issue_1575_2,
"
const obj = {
foo: 5,
async method() {
return this.foo;
}
}
return obj.method().then((res) => expect(res).toBe(5))
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1722_1,
"
(async function main() {
console.log(1)
})(foo);
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1721_1,
"
async function main() {
for await (const x of lol()) {
console.log(x);
}
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1721_2_async_generator,
"
async function* lol() {
yield 1;
yield 2;
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1684_1,
"
const cache = {}
async function getThing(key) {
const it = cache[key] || (await fetchThing(key))
return it
}
function fetchThing(key) {
return Promise.resolve(key.toUpperCase()).then(val => (cache[key] = val))
}
"
);
test!(
Syntax::default(),
|t| {
let unresolved_mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), unresolved_mark),
generator(unresolved_mark, t.comments.clone()),
)
},
issue_1684_2,
"
const cache = {}
async function getThing(key) {
const it = cache[key] || (await fetchThing(key))
return it
}
function fetchThing(key) {
return Promise.resolve(key.toUpperCase()).then(val => (cache[key] = val))
}
"
);
test_exec!(
syntax(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1752_1,
"
async function* generate() {
const results = await Promise.all([
Promise.resolve(1),
Promise.resolve(2),
Promise.resolve(3),
])
for (const result of results) {
console.log(`yield ${result}`)
yield result
}
}
async function printValues() {
const iterator = generate()
for await (const value of iterator) {
console.log(`iterator value: ${value}`)
}
}
printValues()
"
);
test_exec!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_1918_1,
"
let counter = 0;
let resolve;
let promise = new Promise((r) => (resolve = r));
let iterable = {
[Symbol.asyncIterator]() {
return {
next() {
return promise;
},
};
},
};
const res = (async () => {
for await (let value of iterable) {
counter++;
console.log(value);
}
expect(counter).toBe(2);
})();
for (let v of [0, 1]) {
await null;
let oldresolve = resolve;
promise = new Promise((r) => (resolve = r));
oldresolve({ value: v, done: false });
}
resolve({ value: undefined, done: true });
await res;
"
);
test_exec!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_2402_1,
"
function MyClass(item) {
this.item = item;
console.log('Constructor | this.item', this.item);
}
MyClass.prototype.fun = async function fun() {
console.log('fun | this.item', this.item);
return this.item;
};
const tmp = new MyClass({ foo: 'bar' });
expect(tmp.fun()).resolves.toEqual({ foo: 'bar' });
"
);
test!(
Syntax::default(),
|t| {
let unresolved_mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), unresolved_mark),
generator(unresolved_mark, t.comments.clone()),
)
},
issue_2402_2,
"
function MyClass(item) {
this.item = item;
console.log('Constructor | this.item', this.item);
}
MyClass.prototype.fun = async function fun() {
console.log('fun | this.item', this.item);
return this.item;
};
const tmp = new MyClass({ foo: 'bar' });
tmp.fun().then((res) => {
console.log('fun result | item', res);
});
"
);
test_exec!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_2305_1,
"
function MyClass () {}
MyClass.prototype.handle = function () {
console.log('this is MyClass handle')
}
MyClass.prototype.init = async function(param1) {
const a = 1;
if (!param1) {
console.log(this)
this.handle()
}
if (param1 === a) {
return false
}
return true
}
const myclass = new MyClass()
myclass.handle()
expect(myclass.init(2)).resolves.toEqual(true);
"
);
test!(
Syntax::default(),
|t| {
let unresolved_mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), unresolved_mark),
generator(unresolved_mark, t.comments.clone()),
)
},
issue_2305_2,
"
function MyClass () {}
MyClass.prototype.handle = function () {
console.log('this is MyClass handle')
}
MyClass.prototype.init = async function(param1) {
const a = 1;
if (!param1) {
console.log(this)
this.handle()
}
if (param1 === a) {
return false
}
return true
}
const myclass = new MyClass()
myclass.handle()
"
);
test!(
Syntax::default(),
|t| {
let unresolved_mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), unresolved_mark),
generator(unresolved_mark, t.comments.clone()),
)
},
issue_2677_1,
"
async function region() {
}
export async function otherCall() {
await region();
}
export default async function someCall() {
await region();
}
"
);
test!(
Syntax::default(),
|t| {
let unresolved_mark = Mark::fresh(Mark::root());
(
async_to_generator(Default::default(), unresolved_mark),
generator(unresolved_mark, t.comments.clone()),
)
},
issue_2677_2,
"
async function region() {
}
export default async function() {
await region();
}
"
);
test_exec!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
function_parameters,
"
class A {
waitForinit = () => Promise.resolve(3);
doTest() {
throw new Error('should not be called');
}
}
A.prototype.doTest = async function() {
const ret = await this.waitForinit();
return ret;
}
const a = new A();
expect(a.doTest()).resolves.toEqual(3);
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
function_length_issue_3135_1,
r#"
async function foo(x, y, ...z) {
return 42;
}
"#
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
function_length_issue_3135_2,
r#"
async function* foo(x, y, ...z) {
return 42;
}
"#
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
function_length_issue_3135_3,
r#"
const foo = async function (x, y, ...z) {
return 42;
}
"#
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
function_length_issue_3135_4,
r#"
const foo = async function* (x, y, ...z) {
return 42;
}
"#
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
function_length_issue_3135_5,
r#"
const foo = async function foo(x, y, ...z) {
if (x) {
return foo(0, y);
}
return 0;
};
"#
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
function_length_issue_3135_6,
r#"
const foo = async function* foo(x, y, ...z) {
if (x) {
return foo(0, y);
}
return 0;
};
"#
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
function_length_issue_3135_7,
r#"
const foo = async (x, y, ...z) => {
return this;
};
"#
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
async_wrap_this,
r#"
const foo = async (x, y, ...z) => {
return this;
};
"#
);
test!(
Syntax::default(),
|_| with_resolver(),
async_wrap_arguments,
r#"
function foo() {
const bar = async () => {
return arguments;
};
}
"#
);
test!(
Syntax::default(),
|_| with_resolver(),
async_wrap_super_and_new_target,
r#"
class Foo {
constractur() {
const foo = async () => {
return new.target;
};
}
hello() {
const world = async () => {
return super.hello();
};
}
}
"#
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
export_default_async_nested_1,
"
export default async function foo(x) {
async function bar(y){
y(x);
}
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
export_default_async_nested_2,
"
export default async function (x) {
async function bar(y) {
(async (z) => x(y)(z))();
}
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
async_with_optional_params,
"
(async function (a = 10, ...rest) {})();
(async (a = 10, ...rest) => {})()
"
);
test!(
Syntax::default(),
|_| with_resolver(),
issue_2895,
"
export class Quirk {
async doStuff() {
const args = arguments;
console.log(args);
return { foo: null, ...args[0] };
}
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
super_field_update,
"
class Foo {
async doStuff() {
super.foo += 123;
super['abc'] *= 456;
}
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
microbundle_835,
"
class A extends B {
a() {
(async () => {
super.b();
})();
}
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
super_update,
"
class A extends B {
async foo() {
super.foo ++;
-- super.bar;
super['foo'] ++;
-- super['bar'];
}
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
async_with_optional_params_2,
"
const Z = (f) => ((x) => f((y) => x(x)(y)))((x) => f((y) => x(x)(y)));
const p = Z(
(f) =>
async (n = 0) =>
n <= 1 ? 1 : n * (await f(n - 1))
)(5);
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_4208,
"
function foo() {
const bar = async (baz = this.baz) => {
console.log(this);
}
}
"
);
test!(
Syntax::default(),
|_| async_to_generator(Default::default(), Mark::new()),
issue_8452,
r#"
class Test0 {}
class Test extends Test0 {
constructor() {
super(),
console.log(async (e) => {
await this.test();
});
}
}
"#
);
test!(
Syntax::default(),
|_| with_resolver(),
issue_9432,
r#"
class Foo extends Bar {
constructor(options) {
super(
{
callA: async () => {
this.callA();
},
}
);
}
}
"#
);
#[testing::fixture("tests/async-to-generator/**/exec.js")]
fn exec(input: PathBuf) {
let input = read_to_string(input).unwrap();
compare_stdout(
Default::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), unresolved_mark),
)
},
&input,
);
}
#[testing::fixture("tests/async-to-generator/**/exec.js")]
fn exec_regenerator(input: PathBuf) {
let input = read_to_string(input).unwrap();
compare_stdout(
Default::default(),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), unresolved_mark),
es2015::for_of(Default::default()),
block_scoping(unresolved_mark),
generator(unresolved_mark, t.comments.clone()),
)
},
&input,
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2018_object_rest_spread.rs | Rust | use std::path::PathBuf;
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015::{self, spread},
es2018::{object_rest_spread, object_rest_spread::Config},
};
use swc_ecma_transforms_testing::{compare_stdout, test, test_exec, test_fixture};
fn syntax() -> Syntax {
Syntax::default()
}
fn tr(c: Config) -> impl Pass {
object_rest_spread(c)
}
test!(
syntax(),
|_| tr(Default::default()),
issue_233,
"const foo = () => ({ x, ...y }) => y"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_239,
"class Foo {
constructor ({ ...bar }) {}
}"
);
// object rest spread pass should not touch rest in parameters and spread in
// args.
test!(
syntax(),
|_| tr(Default::default()),
issue_227,
"export default function fn1(...args) {
fn2(...args);
}"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_162,
r#"
export const good = {
a(bad1) {
(...bad2) => { };
}
};
"#
);
test!(
syntax(),
|_| tr(Default::default()),
issue_181,
r#"
const fn = ({ a, ...otherProps }) => otherProps;
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_function_array,
r#"
function foo([{...bar}]) {
}
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_var_basic,
r#"
var { a , ...b } = _ref;
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_assignment_exec,
r#"
let foo = {
a: 1,
b: 2,
};
({ a, ...c } = foo);
expect(a).toBe(1);
expect(c).toEqual({b: 2});
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_catch_exec,
r#"
try {
throw {
a2: 1,
b2: 2,
c2: {
c3: 'c3',
extras: 3,
}
};
} catch({a2, b2, c2: { c3, ...c4 }}) {
expect(a2).toBe(1);
expect(b2).toBe(2);
expect(c3).toBe('c3');
expect(c4).toEqual({extras: 3});
}"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_assignment_expression,
r#"({ a1 } = c1);
({ a2, ...b2 } = c2);
console.log({ a3, ...b3 } = c3);"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_catch_clause,
r#"
try {} catch({ ...a34 }) {}
try {} catch({a1, ...b1}) {}
try {} catch({a2, b2, ...c2}) {}
try {} catch({a2, b2, c2: { c3, ...c4 }}) {}
// Unchanged
try {} catch(a) {}
try {} catch({ b }) {}
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_export,
r#"
// ExportNamedDeclaration
export var { b, ...c } = asdf2;
// Skip
export var { bb, cc } = ads;
export var [ dd, ee ] = ads;
"#
);
test!(
syntax(),
|_| (tr(Default::default()), spread(Default::default())),
rest_for_x,
r#"
// ForXStatement
for (var {a, ...b} of []) {}
for ({a, ...b} of []) {}
async function a() {
for await ({a, ...b} of []) {}
}
// skip
for ({a} in {}) {}
for ({a} of []) {}
async function a() {
for await ({a} of []) {}
}
for (a in {}) {}
for (a of []) {}
async function a() {
for await (a of []) {}
}
"#
);
test_exec!(
ignore,
syntax(),
|_| tr(Default::default()),
rest_impure_computed_exec,
r#"
var key, x, y, z;
// impure
key = 1;
var { [key++]: y, ...x } = { 1: 1, a: 1 };
expect(x).toEqual({ a: 1 });
expect(key).toBe(2);
expect(1).toBe(y);
// takes care of the order
key = 1;
var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3};
expect(y).toBe(2);
expect(z).toBe(3);
// pure, computed property should remain as-is
key = 2;
({ [key]: y, z, ...x } = {2: "two", z: "zee"});
expect(y).toBe("two");
expect(x).toEqual({});
expect(z).toBe("zee");
"#
);
test!(
ignore,
syntax(),
|_| tr(Default::default()),
rest_impure_computed,
r#"
var key, x, y, z;
// impure
key = 1;
var { [key++]: y, ...x } = { 1: 1, a: 1 };
expect(x).toEqual({ a: 1 });
expect(key).toBe(2);
expect(y).toBe(1);
// takes care of the order
key = 1;
var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3};
expect(y).toBe(2);
expect(z).toBe(3);
// pure, computed property should remain as-is
key = 2;
({ [key]: y, z, ...x } = {2: "two", z: "zee"});
expect(y).toBe("two");
expect(x).toEqual({});
expect(z).toBe("zee");
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_nested_2,
r#"
const test = {
foo: {
bar: {
baz: {
a: {
x: 1,
y: 2,
z: 3,
},
},
},
},
};
const { foo: { bar: { baz: { a: { x, ...other } } } } } = test;
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_nested_computed_key,
r#"
const {
[({ ...rest }) => {
let { ...b } = {};
}]: a,
[({ ...d } = {})]: c,
} = {};
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_nested_default_value_exec,
r#"
const {
a = ({ ...rest }) => {
expect(rest).toEqual({})
let { ...b } = {};
},
c = ({ ...d } = {}),
} = {};
a({})
expect(c).toEqual({})
expect(d).toEqual({})
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_nested_default_value,
r#"
const {
a = ({ ...rest }) => {
let { ...b } = {};
},
c = ({ ...d } = {}),
} = {};
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_nested_order_exec,
r#"
var result = "";
var obj = {
get foo() {
result += "foo"
},
a: {
get bar() {
result += "bar";
}
},
b: {
get baz() {
result += "baz";
}
}
};
var { a: { ...bar }, b: { ...baz }, ...foo } = obj;
expect(result).toBe("barbazfoo");
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_nested_order,
r#"
const { a: { ...bar }, b: { ...baz }, ...foo } = obj;
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_nested_1,
r#"
const defunct = {
outer: {
inner: {
three: 'three',
four: 'four'
}
}
}
const { outer: { inner: { three, ...other } } } = defunct
"#
);
test_exec!(
ignore,
syntax(),
|_| tr(Default::default()),
rest_non_string_computed_exec,
r#"
const a = {
"3": "three"
"foo": "bar"
}
const {
[3]: omit,
...rest
} = a;
expect(rest).toEqual({"foo": "bar"});
expect(omit).toBe("three");
const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {toString() { return "warrior"; }}];
const c = {
[k1]: "1"
[k2]: "2"
[k3]: "3"
[k4]: "4"
[k5]: "5"
};
const {
[k1]: v1,
[k2]: v2,
[k3]: v3,
[k4]: v4,
[k5]: v5,
...vrest
} = c;
expect(v1).toBe("1");
expect(v2).toBe("2");
expect(v3).toBe("3");
expect(v4).toBe("4");
expect(v5).toBe("5");
expect(vrest).toEqual({});
// shouldn't convert symbols to strings
const sx = Symbol();
const sy = Symbol();
const d = {
[sx]: "sx"
[sy]: "sy"
}
const {
[sx]: dx,
[sy]: dy
} = d;
expect(dx).toBe("sx");
expect(dy).toBe("sy");
"#
);
test!(
ignore,
syntax(),
|_| tr(Default::default()),
rest_non_string_computed,
r#"
const a = {
"3": "three"
"foo": "bar"
}
const {
[3]: omit,
...rest
} = a;
expect(rest).toEqual({"foo": "bar"});
expect(omit).toBe("three");
const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {toString() { return "warrior"; }}];
const c = {
[k1]: "1"
[k2]: "2"
[k3]: "3"
[k4]: "4"
[k5]: "5"
};
const {
[k1]: v1,
[k2]: v2,
[k3]: v3,
[k4]: v4,
[k5]: v5,
...vrest
} = c;
expect(v1).toBe("1");
expect(v2).toBe("2");
expect(v3).toBe("3");
expect(v4).toBe("4");
expect(v5).toBe("5");
expect(vrest).toEqual({});
// shouldn't convert symbols to strings
const sx = Symbol();
const sy = Symbol();
const d = {
[sx]: "sx"
[sy]: "sy"
}
const {
[sx]: dx,
[sy]: dy
} = d;
expect(dx).toBe("sx");
expect(dy).toBe("sy");"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_symbol_exec,
r#"
const sym = Symbol("test");
const sym2 = Symbol("not enumerable");
const src = { a: "string" };
Object.defineProperty(src, "b", { value: "not enumerable" })
Object.defineProperty(src, sym, { enumerable: true, value: "symbol" });
Object.defineProperty(src, sym2, { value: "not enumerable" });
const {...rest} = src;
expect(rest[sym]).toBe("symbol");
expect(rest.a).toBe("string");
expect(Object.getOwnPropertyNames(rest)).toEqual(["a"]);
expect(Object.getOwnPropertySymbols(rest)).toEqual([sym]);
const { [sym]: dst, ...noSym } = src;
expect(dst).toBe("symbol");
expect(noSym.a).toBe("string");
expect(Object.getOwnPropertySymbols(noSym)).toEqual([]);"#
);
test!(
ignore,
syntax(),
|_| tr(Default::default()),
rest_symbol,
r#"
let {
[Symbol.for("foo")]: foo,
...rest
} = {};
({ [Symbol.for("foo")]: foo, ...rest } = {});
if ({ [Symbol.for("foo")]: foo, ...rest } = {}) {}
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_variable_destructuring_1,
r#"
var z = {};
var { ...x } = z;
var { ...a } = { a: 1 };
var { ...x } = a.b;
var { ...x } = a();
var {x1, ...y1} = z;
x1++;
var { [a]: b, ...c } = z;
var {x1, ...y1} = z;
let {x2, y2, ...z2} = z;
const {w3, x3, y3, ...z4} = z;
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_variable_destructuring_2,
r#"
let {
x: { a: xa, [d]: f, ...asdf },
y: { ...d },
...g
} = complex;
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_variable_destructuring_3,
r#"
let { x4: { ...y4 } } = z;
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_with_array_rest_exec,
r#"
let [{ a, ...foo}, ...bar] = [{ a: 1, b:2 }, 2, 3, 4];
expect(a).toBe(1)
expect(foo).toEqual({b: 2});
expect(bar).toEqual([2, 3, 4]);
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
rest_with_array_rest_exec_2,
r#"
let {
a: [b, ...arrayRest],
c = function(...functionRest){},
...objectRest
} = {
a: [1, 2, 3, 4],
d: "oyez"
};
expect(b).toBe(1);
expect(arrayRest).toEqual([2, 3, 4]);
expect(objectRest).toEqual({d: 'oyez'})
"#
);
test!(
syntax(),
|_| tr(Default::default()),
rest_with_array_rest,
r#"
let {
a: [b, ...arrayRest],
c = function(...functionRest){},
...objectRest
} = {
a: [1, 2, 3, 4],
d: "oyez"
};
"#
);
test!(
syntax(),
|_| tr(Default::default()),
spread_assignment,
r#"
z = { x, ...y };
z = { x, w: { ...y } };
"#
);
test!(
syntax(),
|_| tr(Default::default()),
object_spread_expression,
r#"
({ x, ...y, a, ...b, c });
({ ...Object.prototype });
({ ...{ foo: 'bar' } });
({ ...{ get foo () { return 'foo' } } });
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
spread_no_object_assign_exec,
r#"
Object.defineProperty(Object.prototype, 'NOSET', {
set(value) {
// noop
},
});
Object.defineProperty(Object.prototype, 'NOWRITE', {
writable: false,
value: 'abc',
});
const obj = { NOSET: 123 };
// this wouldn't work as expected if transformed as Object.assign (or equivalent)
// because those trigger object setters (spread don't)
const objSpread = { ...obj };
const obj2 = { NOSET: 123, NOWRITE: 456 };
// this line would throw `TypeError: Cannot assign to read only property 'NOWRITE'`
// if transformed as Object.assign (or equivalent) because
// those use *assignment* for creating properties
// (spread defines them)
const obj2Spread = { ...obj2 };
expect(objSpread).toEqual(obj);
expect(obj2Spread).toEqual(obj2);
const KEY = Symbol('key');
const obj3Spread = { ...{ get foo () { return 'bar' } }, [KEY]: 'symbol' };
expect(Object.getOwnPropertyDescriptor(obj3Spread, 'foo').value).toBe('bar');
expect(Object.getOwnPropertyDescriptor(obj3Spread, KEY).value).toBe('symbol');
const obj4Spread = { ...Object.prototype };
expect(Object.getOwnPropertyDescriptor(obj4Spread, 'hasOwnProperty')).toBeUndefined();
expect(() => ({ ...null, ...undefined })).not.toThrow();
const o = Object.create(null);
o.a = 'foo';
o.__proto__ = [];
const o2 = { ...o };
expect(Array.isArray(Object.getPrototypeOf(o2))).toBe(false);
"#
);
test!(
syntax(),
|_| tr(Default::default()),
spread_variable_declaration,
r#"var z = { ...x };"#
);
// object_spread_assignment
test!(
syntax(),
|_| tr(Default::default()),
object_spread_assignment,
r#"
z = { x, ...y };
z = { x, w: { ...y } };
"#
);
//// regression_gh_7304
//test!(syntax(),|_| tr("{
// "presets": [
// [
// "env"
// {
// "shippedProposals": true,
// "targets": {
// "node": 8
// },
// "useBuiltIns": "usage"
// "corejs": 3
// }
// ]
// ],
// "plugins": []
//}
//"), regression_gh_7304, r#"
//export default class {
// method ({ ...object }) {}
//}
//"# r#"
//"use strict";
//
//Object.defineProperty(exports, "__esModule" {
// value: true
//});
//exports.default = void 0;
//
//class _default {
// method(_ref) {
// let object = Object.assign({}, _ref);
// }
//
//}
//
//exports.default = _default;
//
//"#);
//// object_rest_symbol
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_symbol, r#"
//let {
// [Symbol.for("foo")]: foo,
// ...rest
//} = {};
//
//({ [Symbol.for("foo")]: foo, ...rest } = {});
//
//if ({ [Symbol.for("foo")]: foo, ...rest } = {}) {}
//
//"# r#"
//var _ref3, _Symbol$for3;
//
//let _ref = {},
// _Symbol$for = Symbol.for("foo"),
// {
// [_Symbol$for]: foo
//} = _ref,
// rest = _object_without_properties(_ref,
// [_Symbol$for].map(_to_property_key));
//
//var _ref2 = {};
//
//var _Symbol$for2 = Symbol.for("foo");
//
//({
// [_Symbol$for2]: foo
//} = _ref2);
//rest = _object_without_properties(_ref2,
// [_Symbol$for2].map(_to_property_key));
//_ref2;
//
//if (_ref3 = {}, _Symbol$for3 = Symbol.for("foo"), ({
// [_Symbol$for3]: foo
//} = _ref3), rest = _object_without_properties(_ref3,
//} [_Symbol$for3].map(_to_property_key)), _ref3) {}
//
//"#);
// object_rest_symbol_exec_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
object_rest_symbol_exec_exec,
r#"
const sym = Symbol("test");
const sym2 = Symbol("not enumerable");
const src = { a: "string" };
Object.defineProperty(src, "b", { value: "not enumerable" })
Object.defineProperty(src, sym, { enumerable: true, value: "symbol" });
Object.defineProperty(src, sym2, { value: "not enumerable" });
const {...rest} = src;
expect(rest[sym]).toBe("symbol");
expect(rest.a).toBe("string");
expect(Object.getOwnPropertyNames(rest)).toEqual(["a"]);
expect(Object.getOwnPropertySymbols(rest)).toEqual([sym]);
const { [sym]: dst, ...noSym } = src;
expect(dst).toBe("symbol");
expect(noSym.a).toBe("string");
expect(Object.getOwnPropertySymbols(noSym)).toEqual([]);
"#
);
//// object_rest_impure_computed
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_impure_computed, r#"
//var key, x, y, z;
//// impure
//key = 1;
//var { [key++]: y, ...x } = { 1: 1, a: 1 };
//expect(x).toEqual({ a: 1 });
//expect(key).toBe(2);
//expect(y).toBe(1);
//
//// takes care of the order
//
//key = 1;
//var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3};
//expect(y).toBe(2);
//expect(z).toBe(3);
//
//// pure, computed property should remain as-is
//key = 2;
//({ [key]: y, z, ...x } = {2: "two", z: "zee"});
//expect(y).toBe("two");
//expect(x).toEqual({});
//expect(z).toBe("zee");
//
//"# r#"
//var key, x, y, z; // impure
//
//key = 1;
//
//var _$a = {
// 1: 1,
// a: 1
//},
// _ref = key++,
// {
// [_ref]: y
//} = _$a,
// x = _object_without_properties(_$a,
// [_ref].map(_to_property_key));
//
//expect(x).toEqual({
// a: 1
//});
//expect(key).toBe(2);
//expect(y).toBe(1); // takes care of the order
//
//key = 1;
//
//var _$ = {
// 2: 2,
// 3: 3
//},
// _ref2 = ++key,
// _ref3 = ++key,
// {
// [_ref2]: y,
// [_ref3]: z
//} = _$,
// rest = _object_without_properties(_$, [_ref2,
// _ref3].map(_to_property_key));
//
//expect(y).toBe(2);
//expect(z).toBe(3); // pure, computed property should remain as-is
//
//key = 2;
//var _$z = {
// 2: "two"
// z: "zee"
//};
//({
// [key]: y,
// z
//} = _$z);
//x = _object_without_properties(_$z, [key,
// "z"].map(_to_property_key));
//_$z;
//expect(y).toBe("two");
//expect(x).toEqual({});
//expect(z).toBe("zee");
//
//"#);
//// object_rest_catch_clause
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_catch_clause, r#"
//try {} catch({ ...a34 }) {}
//try {} catch({a1, ...b1}) {}
//try {} catch({a2, b2, ...c2}) {}
//try {} catch({a2, b2, c2: { c3, ...c4 }}) {}
//
//// Unchanged
//try {} catch(a) {}
//try {} catch({ b }) {}
//
//"# r#"
//try {} catch (_ref) {
// let a34 = _extends({}, _ref);
//}
//
//try {} catch (_ref2) {
// let {
// a1
// } = _ref2,
// b1 = _object_without_properties(_ref2, ["a1"]);
//}
//
//try {} catch (_ref3) {
// let {
// a2,
// b2
// } = _ref3,
// c2 = _object_without_properties(_ref3, ["a2" "b2"]);
//}
//
//try {} catch (_ref4) {
// let {
// a2,
// b2,
// c2: {
// c3
// }
// } = _ref4,
// c4 = _object_without_properties(_ref4.c2, ["c3"]);
//} // Unchanged
//
//
//try {} catch (a) {}
//
//try {} catch ({
// b
//}) {}
//
//"#);
//// object_rest_variable_destructuring
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_variable_destructuring, r#"
//var z = {};
//var { ...x } = z;
//var { ...a } = { a: 1 };
//var { ...x } = a.b;
//var { ...x } = a();
//var {x1, ...y1} = z;
//x1++;
//var { [a]: b, ...c } = z;
//var {x1, ...y1} = z;
//let {x2, y2, ...z2} = z;
//const {w3, x3, y3, ...z4} = z;
//
//let {
// x: { a: xa, [d]: f, ...asdf },
// y: { ...d },
// ...g
//} = complex;
//
//let { x4: { ...y4 } } = z;
//
//"# r#"
//var z = {};
//var x = _extends({}, z);
//var a = _extends({}, {
// a: 1
//});
//var x = _extends({}, a.b);
//var x = _extends({}, a());
//var {
// x1
//} = z,
// y1 = _object_without_properties(z, ["x1"]);
//x1++;
//var {
// [a]: b
//} = z,
// c = _object_without_properties(z,
// [a].map(_to_property_key)); var {
// x1
//} = z,
// y1 = _object_without_properties(z, ["x1"]);
//let {
// x2,
// y2
//} = z,
// z2 = _object_without_properties(z, ["x2" "y2"]);
//const {
// w3,
// x3,
// y3
//} = z,
// z4 = _object_without_properties(z, ["w3" "x3" "y3"]);
//let {
// x: {
// a: xa,
// [d]: f
// }
//} = complex,
// asdf = _object_without_properties(complex.x, ["a"
// d].map(_to_property_key)), d = _extends({},
// complex.y), g = _object_without_properties(complex, ["x"]);
//let {} = z,
// y4 = _extends({}, z.x4);
//
//"#);
// object_rest_non_string_computed_exec
//// regression_gh_8323
//test!(syntax(),|_| tr("{
// "presets": [["env" { "targets": { "node": "8" } }]],
// "plugins": [["proposal-object-rest-spread" { "loose": true }]]
//}
//"), regression_gh_8323, r#"
//const get = () => {
// fireTheMissiles();
// return 3;
//};
//
//const f = ({ a = get(), b, c, ...z }) => {
// const v = b + 3;
//};
//
//"# r#"
//const get = () => {
// fireTheMissiles();
// return 3;
//};
//
//const f = (_ref) => {
// let {
// a = get(),
// b
// } = _ref,
// z = _object_without_properties_loose(_ref, ["a" "b" "c"]);
//
// const v = b + 3;
//};
//
//"#);
// regression_gh_5151
test!(
syntax(),
|_| tr(Default::default()),
regression_gh_5151,
r#"
const { x, ...y } = a,
z = foo(y);
const { ...s } = r,
t = foo(s);
// ordering is preserved
var l = foo(),
{ m: { n, ...o }, ...p } = bar(),
q = baz();
"#
);
// object_rest_parameters
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_parameters, r#"
//function a({ ...a34 }) {}
//function a2({a1, ...b1}) {}
//function a3({a2, b2, ...c2}) {}
//function a4({a3, ...c3}, {a5, ...c5}) {}
//function a5({a3, b2: { ba1, ...ba2 }, ...c3}) {}
//function a6({a3, b2: { ba1, ...ba2 } }) {}
//function a7({a1 = 1, ...b1} = {}) {}
//function a8([{...a1}]) {}
//function a9([{a1, ...a2}]) {}
//function a10([a1, {...a2}]) {}
//// Unchanged
//function b(a) {}
//function b2(a, ...b) {}
//function b3({ b }) {}
//
//"# r#"
//function a(_ref) {
// let a34 = _extends({}, _ref);
//}
//
//function a2(_ref2) {
// let {
// a1
// } = _ref2,
// b1 = _object_without_properties(_ref2, ["a1"]);
//}
//
//function a3(_ref3) {
// let {
// a2,
// b2
// } = _ref3,
// c2 = _object_without_properties(_ref3, ["a2" "b2"]);
//}
//
//function a4(_ref5, _ref4) {
// let {
// a3
// } = _ref5,
// c3 = _object_without_properties(_ref5, ["a3"]);
// let {
// a5
// } = _ref4,
// c5 = _object_without_properties(_ref4, ["a5"]);
//}
//
//function a5(_ref6) {
// let {
// a3,
// b2: {
// ba1
// }
// } = _ref6,
// ba2 = _object_without_properties(_ref6.b2, ["ba1"]),
// c3 = _object_without_properties(_ref6, ["a3" "b2"]);
//}
//
//function a6(_ref7) {
// let {
// a3,
// b2: {
// ba1
// }
// } = _ref7,
// ba2 = _object_without_properties(_ref7.b2, ["ba1"]);
//}
//
//function a7(_ref8 = {}) {
// let {
// a1 = 1
// } = _ref8,
// b1 = _object_without_properties(_ref8, ["a1"]);
//}
//
//function a8([_ref9]) {
// let a1 = _extends({}, _ref9);
//}
//
//function a9([_ref10]) {
// let {
// a1
// } = _ref10,
// a2 = _object_without_properties(_ref10, ["a1"]);
//}
//
//function a10([a1, _ref11]) {
// let a2 = _extends({}, _ref11);
//} // Unchanged
//
//
//function b(a) {}
//
//function b2(a, ...b) {}
//
//function b3({
// b
//}) {}
//
//"#);
//// object_rest_for_x_array_pattern
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_for_x_array_pattern, r#"
//// ForXStatement
//for (const [{a, ...b}] of []) {}
//for ([{a, ...b}] of []) {}
//async function a() {
// for await ([{a, ...b}] of []) {}
//}
//
//// skip
//for ([{a}] in {}) {}
//for ([{a}] of []) {}
//async function a() {
// for await ([{a}] of []) {}
//}
//
//for ([a, ...b] in {}) {}
//for ([a, ...b] of []) {}
//async function a() {
// for await ([a, ...b] of []) {}
//}
//
//"# r#"
//// ForXStatement
//for (const _ref of []) {
// const [_ref2] = _ref;
// const {
// a
// } = _ref2,
// b = _object_without_properties(_ref2, ["a"]);
//}
//
//for (var _ref3 of []) {
// [_ref4] = _ref3;
// var {
// a
// } = _ref4,
// b = _object_without_properties(_ref4, ["a"]);
//}
//
//async function a() {
// for await (var _ref5 of []) {
// [_ref6] = _ref5;
// var {
// a
// } = _ref6,
// b = _object_without_properties(_ref6, ["a"]);
// }
//} // skip
//
//
//for ([{
// a
//}] in {}) {}
//
//for ([{
// a
//}] of []) {}
//
//async function a() {
// for await ([{
// a
// }] of []) {}
//}
//
//for ([a, ...b] in {}) {}
//
//for ([a, ...b] of []) {}
//
//async function a() {
// for await ([a, ...b] of []) {}
//}
//
//"#);
//// object_rest_nested_computed_key
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_nested_computed_key, r#"
//const {
// [({ ...rest }) => {
// let { ...b } = {};
// }]: a,
// [({ ...d } = {})]: c,
//} = {};
//"# r#"
//var _ref2;
//
//const {
// [(_ref) => {
// let rest = _extends({}, _ref);
// let b = _extends({}, {});
// }]: a,
// [(_ref2 = {}, ({} = _ref2), d = _extends({}, _ref2), _ref2)]: c
//} = {};
//
//"#);
// regression_gh_7388
test!(
syntax(),
|_| tr(Default::default()),
regression_gh_7388,
r#"
function fn0(obj0) {
const {
fn1 = (obj1 = {}) => {
const {
fn2 = (obj2 = {}) => {
const {a, ...rest} = obj2;
console.log(rest);
}
} = obj1;
}
} = obj0;
}
"#
);
// object_rest_impure_computed_exec
//// object_rest_nested
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_nested, r#"
//const defunct = {
// outer: {
// inner: {
// three: 'three',
// four: 'four'
// }
// }
//}
//
//const { outer: { inner: { three, ...other } } } = defunct
//
//"# r#"
//const defunct = {
// outer: {
// inner: {
// three: 'three',
// four: 'four'
// }
// }
//};
//const {
// outer: {
// inner: {
// three
// }
// }
//} = defunct,
// other = _object_without_properties(defunct.outer.inner,
// ["three"]);
//
//"#);
//// object_rest_with_array_rest
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_with_array_rest, r#"
//let {
// a: [b, ...arrayRest],
// c = function(...functionRest){},
// ...objectRest
//} = {
// a: [1, 2, 3, 4],
// d: "oyez"
//};
//
//"# r#"
//let _a$d = {
// a: [1, 2, 3, 4],
// d: "oyez"
//},
// {
// a: [b, ...arrayRest],
// c = function (...functionRest) {}
//} = _a$d,
// objectRest = _object_without_properties(_a$d, ["a" "c"]);
//
//"#);
//// object_rest_nested_array_2
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_nested_array_2, r#"
//const [a, [{b, ...c}], {d, ...e}, [{ f, ...g}, {h: [i, {j, ...k}] }]] = x;
//
//"# r#"
//const [a, [_ref], _ref2, [_ref3, {
// h: [i, _ref4]
//}]] = x;
//const {
// b
//} = _ref,
// c = _object_without_properties(_ref, ["b"]),
// {
// d
//} = _ref2,
// e = _object_without_properties(_ref2, ["d"]),
// {
// f
//} = _ref3,
// g = _object_without_properties(_ref3, ["f"]),
// {
// j
//} = _ref4,
// k = _object_without_properties(_ref4, ["j"]);
//
//"#);
// object_rest_impure_computed_exec_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
object_rest_impure_computed_exec_exec,
r#"
var key, x, y, z;
// impure
key = 1;
var { [key++]: y, ...x } = { 1: 1, a: 1 };
expect(x).toEqual({ a: 1 });
expect(key).toBe(2);
expect(1).toBe(y);
// takes care of the order
key = 1;
var { [++key]: y, [++key]: z, ...rest} = {2: 2, 3: 3};
expect(y).toBe(2);
expect(z).toBe(3);
// pure, computed property should remain as-is
key = 2;
({ [key]: y, z, ...x } = {2: "two", z: "zee"});
expect(y).toBe("two");
expect(x).toEqual({});
expect(z).toBe("zee");
// rhs evaluated before lhs
var order = [];
function left() {
order.push("left");
return 0;
}
function right() {
order.push("right");
return {};
}
var { [left()]: y, ...x} = right();
expect(order).toEqual(["right", "left"]);
"#
);
//// object_rest_duplicate_decl_bug
//test!(syntax(),|_| tr("{
// "plugins": [
// "./plugin-clear-scope"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_duplicate_decl_bug, r#"
//it("es7.objectRestSpread" () => {
// let original = { a: 1, b: 2 };
// let { ...copy } = original;
//});
//
//"# r#"
//it("es7.objectRestSpread" () => {
// let original = {
// a: 1,
// b: 2
// };
// let copy = _extends({}, original);
//});
//
//"#);
// object_spread_expression_exec
test_exec!(
// WTF? babel's output is wrong
ignore,
syntax(),
|_| tr(Default::default()),
object_spread_expression_exec,
r#"
var log = [];
var a = {
...{ get foo() { log.push(1); } },
get bar() { log.push(2); }
};
expect(log).toEqual([1]);
"#
);
// object_rest_nested_default_value
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_nested_default_value, r#"
//const {
// a = ({ ...rest }) => {
// let { ...b } = {};
// },
// c = ({ ...d } = {}),
//} = {};
//"# r#"
//var _ref2;
//
//const {
// a = (_ref) => {
// let rest = _extends({}, _ref);
// let b = _extends({}, {});
// },
// c = (_ref2 = {}, ({} = _ref2), d = _extends({}, _ref2), _ref2)
//} = {};
//
//"#);
//// object_rest_export
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_export, r#"
//// ExportNamedDeclaration
//export var { b, ...c } = asdf2;
//// Skip
//export var { bb, cc } = ads;
//export var [ dd, ee ] = ads;
//
//"# r#"
//// ExportNamedDeclaration
//var {
// b
//} = asdf2,
// c = _object_without_properties(asdf2, ["b"]); // Skip
//
//export { b, c };
//export var {
// bb,
// cc
//} = ads;
//export var [dd, ee] = ads;
//
//"#);
//// object_rest_non_string_computed
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_non_string_computed, r#"
//const a = {
// "3": "three"
// "foo": "bar"
//}
//
//const {
// [3]: omit,
// ...rest
//} = a;
//
//expect(rest).toEqual({"foo": "bar"});
//expect(omit).toBe("three");
//
//const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {toString() {
// return "warrior"; }}]; const c = {
// [k1]: "1"
// [k2]: "2"
// [k3]: "3"
// [k4]: "4"
// [k5]: "5"
//};
//
//const {
// [k1]: v1,
// [k2]: v2,
// [k3]: v3,
// [k4]: v4,
// [k5]: v5,
// ...vrest
//} = c;
//
//expect(v1).toBe("1");
//expect(v2).toBe("2");
//expect(v3).toBe("3");
//expect(v4).toBe("4");
//expect(v5).toBe("5");
//expect(vrest).toEqual({});
//
//// shouldn't convert symbols to strings
//const sx = Symbol();
//const sy = Symbol();
//
//const d = {
// [sx]: "sx"
// [sy]: "sy"
//}
//
//const {
// [sx]: dx,
// [sy]: dy
//} = d;
//
//expect(dx).toBe("sx");
//expect(dy).toBe("sy");
//
//"# r#"
//const a = {
// "3": "three"
// "foo": "bar"
//};
//const {
// [3]: omit
//} = a,
// rest = _object_without_properties(a, ["3"]);
//expect(rest).toEqual({
// "foo": "bar"
//});
//expect(omit).toBe("three");
//const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {
// toString() {
// return "warrior";
// }
//
//}];
//const c = {
// [k1]: "1"
// [k2]: "2"
// [k3]: "3"
// [k4]: "4"
// [k5]: "5"
//};
//const {
// [k1]: v1,
// [k2]: v2,
// [k3]: v3,
// [k4]: v4,
// [k5]: v5
//} = c,
// vrest = _object_without_properties(c, [k1, k2, k3, k4,
// k5].map(_to_property_key)); expect(v1).toBe("1");
//expect(v2).toBe("2");
//expect(v3).toBe("3");
//expect(v4).toBe("4");
//expect(v5).toBe("5");
//expect(vrest).toEqual({}); // shouldn't convert symbols to strings
//
//const sx = Symbol();
//const sy = Symbol();
//const d = {
// [sx]: "sx"
// [sy]: "sy"
//};
//const {
// [sx]: dx,
// [sy]: dy
//} = d;
//expect(dx).toBe("sx");
//expect(dy).toBe("sy");
//
//"#);
// object_spread_variable_declaration
test!(
syntax(),
|_| tr(Default::default()),
object_spread_variable_declaration,
r#"
var z = { ...x };
"#
);
//// object_rest_nested_array
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_nested_array, r#"
//const [a, {b, ...c}] = x;
//
//let [d, {e, ...f}] = x;
//
//[g, {h, ...i}] = x;
//
//
//"# r#"
//const [a, _ref] = x;
//const {
// b
//} = _ref,
// c = _object_without_properties(_ref, ["b"]);
//let [d, _ref2] = x;
//let {
// e
//} = _ref2,
// f = _object_without_properties(_ref2, ["e"]);
//[g, _ref3] = x;
//var {
// h
//} = _ref3,
// i = _object_without_properties(_ref3, ["h"]);
//
//"#);
// object_spread_no_object_assign_exec_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
object_spread_no_object_assign_exec_exec,
r#"
Object.defineProperty(Object.prototype, 'NOSET', {
set(value) {
// noop
},
});
Object.defineProperty(Object.prototype, 'NOWRITE', {
writable: false,
value: 'abc',
});
const obj = { NOSET: 123 };
// this wouldn't work as expected if transformed as Object.assign (or equivalent)
// because those trigger object setters (spread don't)
const objSpread = { ...obj };
const obj2 = { NOSET: 123, NOWRITE: 456 };
// this line would throw `TypeError: Cannot assign to read only property 'NOWRITE'`
// if transformed as Object.assign (or equivalent) because those use *assignment* for creating properties
// (spread defines them)
const obj2Spread = { ...obj2 };
expect(objSpread).toEqual(obj);
expect(obj2Spread).toEqual(obj2);
const KEY = Symbol('key');
const obj3Spread = { ...{ get foo () { return 'bar' } }, [KEY]: 'symbol' };
expect(Object.getOwnPropertyDescriptor(obj3Spread, 'foo').value).toBe('bar');
expect(Object.getOwnPropertyDescriptor(obj3Spread, KEY).value).toBe('symbol');
const obj4Spread = { ...Object.prototype };
expect(Object.getOwnPropertyDescriptor(obj4Spread, 'hasOwnProperty')).toBeUndefined();
expect(() => ({ ...null, ...undefined })).not.toThrow();
const o = Object.create(null);
o.a = 'foo';
o.__proto__ = [];
const o2 = { ...o };
expect(Array.isArray(Object.getPrototypeOf(o2))).toBe(false);
"#
);
// object_rest_non_string_computed_exec_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
object_rest_non_string_computed_exec_exec,
r#"
const a = {
"3": "three",
"foo": "bar",
}
const {
[3]: omit,
...rest
} = a;
expect(rest).toEqual({"foo": "bar"});
expect(omit).toBe("three");
const [k1, k2, k3, k4, k5] = [null, undefined, true, false, {toString() { return "warrior"; }}];
const c = {
[k1]: "1",
[k2]: "2",
[k3]: "3",
[k4]: "4",
[k5]: "5",
};
const {
[k1]: v1,
[k2]: v2,
[k3]: v3,
[k4]: v4,
[k5]: v5,
...vrest
} = c;
expect(v1).toBe("1");
expect(v2).toBe("2");
expect(v3).toBe("3");
expect(v4).toBe("4");
expect(v5).toBe("5");
expect(vrest).toEqual({});
// shouldn't convert symbols to strings
const sx = Symbol();
const sy = Symbol();
const d = {
[sx]: "sx",
[sy]: "sy",
}
const {
[sx]: dx,
[sy]: dy
} = d;
expect(dx).toBe("sx");
expect(dy).toBe("sy");
"#
);
// object_rest_variable_exec
// object_rest_variable_exec_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
object_rest_variable_exec_exec,
r#"
// var { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
// expect(x).toBe(1);
// expect(y).toBe(2);
// expect(z).toEqual({ a: 3, b: 4 });
// var complex = {
// x: { a: 1, b: 2, c: 3 },
// };
// var {
// x: { a: xa, ...xbc }
// } = complex;
// expect(xa).toBe(1);
// expect(xbc).toEqual({ b: 2, c: 3});
// // own properties
// function ownX({ ...properties }) {
// return properties.x;
// }
// expect(ownX(Object.create({ x: 1 }))).toBeUndefined();
"#
);
//// object_rest_nested_2
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_nested_2, r#"
//const test = {
// foo: {
// bar: {
// baz: {
// a: {
// x: 1,
// y: 2,
// z: 3,
// },
// },
// },
// },
//};
//
//const { foo: { bar: { baz: { a: { x, ...other } } } } } = test;
//
//"# r#"
//const test = {
// foo: {
// bar: {
// baz: {
// a: {
// x: 1,
// y: 2,
// z: 3
// }
// }
// }
// }
//};
//const {
// foo: {
// bar: {
// baz: {
// a: {
// x
// }
// }
// }
// }
//} = test,
// other = _object_without_properties(test.foo.bar.baz.a, ["x"]);
//
//"#);
// object_spread_no_getOwnPropertyDescriptors_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
object_spread_no_get_own_property_descriptors_exec,
r#"
const oldGOPDs = Object.getOwnPropertyDescriptors;
Object.getOwnPropertyDescriptors = null;
({ ...{ a: 1 }, b: 1, ...{} });
Object.getOwnPropertyDescriptors = oldGOPDs;
"#
);
//// object_rest_for_x
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_for_x, r#"
//// ForXStatement
//for (var {a, ...b} of []) {}
//for ({a, ...b} of []) {}
//async function a() {
// for await ({a, ...b} of []) {}
//}
//
//// skip
//for ({a} in {}) {}
//for ({a} of []) {}
//async function a() {
// for await ({a} of []) {}
//}
//
//for (a in {}) {}
//for (a of []) {}
//async function a() {
// for await (a of []) {}
//}
//
//"# r#"
//// ForXStatement
//for (var _ref of []) {
// var {
// a
// } = _ref,
// b = _object_without_properties(_ref, ["a"]);
//}
//
//for (var _ref2 of []) {
// var _ref3 = _ref2;
// ({
// a
// } = _ref3);
// b = _object_without_properties(_ref3, ["a"]);
// _ref3;
//}
//
//async function a() {
// for await (var _ref4 of []) {
// var _ref5 = _ref4;
// ({
// a
// } = _ref5);
// b = _object_without_properties(_ref5, ["a"]);
// _ref5;
// }
//} // skip
//
//
//for ({
// a
//} in {}) {}
//
//for ({
// a
//} of []) {}
//
//async function a() {
// for await ({
// a
// } of []) {}
//}
//
//for (a in {}) {}
//
//for (a of []) {}
//
//async function a() {
// for await (a of []) {}
//}
//
//"#);
//// object_rest_template_literal_property_allLiterals_false
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_template_literal_property_allLiterals_false, r#"
//const input = {};
//
//const {
// given_name: givenName,
// 'last_name': lastName,
// [`country`]: country,
// [prefix + 'state']: state,
// [`${prefix}consents`]: consents,
// ...rest
//} = input;
//
//"# r#"
//const input = {};
//
//const _ref = prefix + 'state',
// _ref2 = `${prefix}consents`,
// {
// given_name: givenName,
// 'last_name': lastName,
// [`country`]: country,
// [_ref]: state,
// [_ref2]: consents
//} = input,
// rest = _object_without_properties(input, ["given_name"
// "last_name" `country`, _ref, _ref2].map(_to_property_key));
//
//"#);
//// object_rest_for_x_completion_record
//test!(syntax(),|_| tr("{
// "plugins": [
// "syntax-async-generators"
// "proposal-object-rest-spread"
//
// ]
//}
//"), object_rest_for_x_completion_record, r#"
//for ({a, ...b} of []) {}
//
//"# r#"
//for (var _ref of []) {
// var _ref2 = _ref;
// ({
// a
// } = _ref2);
// b = _object_without_properties(_ref2, ["a"]);
// _ref2;
// void 0;
//}
//
//"#);
// regression_gh_4904
test!(
syntax(),
|_| tr(Default::default()),
regression_gh_4904,
r#"
const { s, ...t } = foo();
const { s: { q1, ...q2 }, ...q3 } = bar();
const { a } = foo(({ b, ...c }) => {
console.log(b, c);
});
"#
);
test!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
no_symbol_rest_assignment_expression,
r#"({ a, b, ...c } = obj);"#
);
test!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
no_symbol_computed,
r#"let { [a]: b, ...c } = obj;"#
);
test_exec!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
set_property_ignore_symbol_exec,
r#"
let sym = Symbol();
let { a, ...r } = { a: 1, b: 2, [sym]: 3 };
expect(a).toBe(1);
expect(r.b).toBe(2);
expect(sym in r).toBe(false);
"#
);
test!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
no_symbol_rest_nested,
r#"let { a, nested: { b, c, ...d }, e } = obj;"#
);
test!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
no_symbol_var_declaration,
r#"var { a, b, ...c } = obj;"#
);
test!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
set_property_assignment,
r#"
var x;
var y;
var z;
z = { x, ...y };
z = { x, w: { ...y } };
"#
);
test!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
set_property_expression,
r#"
var a;
var b;
var c;
var d;
var x;
var y;
({ x, ...y, a, ...b, c });
({ ...Object.prototype });
({ ...{ foo: 'bar' } });
({ ...{ foo: 'bar' }, ...{ bar: 'baz' } });
({ ...{ get foo () { return 'foo' } } });
"#
);
test_exec!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
set_property_expression_exec,
r#"
var log = [];
var a = {
...{ get foo() { log.push(1); } },
get bar() { log.push(2); }
};
// Loose mode uses regular Get, not GetOwnProperty.
expect(log).toEqual([1, 2]);
"#
);
test_exec!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
set_property_no_get_own_property_exec,
r#"
const oldGOPDs = Object.getOwnPropertyDescriptors;
Object.getOwnPropertyDescriptors = null;
try {
({ ...{ a: 1 }, b: 1, ...{} });
} finally {
Object.getOwnPropertyDescriptors = oldGOPDs;
}
"#
);
test_exec!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
set_property_no_object_assign_exec,
r#"
"use strict";
Object.defineProperty(Object.prototype, 'NOSET', {
get(value) {
// noop
},
});
Object.defineProperty(Object.prototype, 'NOWRITE', {
writable: false,
value: 'abc',
});
const obj = { 'NOSET': 123 };
// this won't work as expected if transformed as Object.assign (or equivalent)
// because those trigger object setters (spread don't)
expect(() => {
const objSpread = { ...obj };
}).toThrow();
const obj2 = { 'NOWRITE': 456 };
// this throws `TypeError: Cannot assign to read only property 'NOWRITE'`
// if transformed as Object.assign (or equivalent) because those use *assignment* for creating properties
// (spread defines them)
expect(() => {
const obj2Spread = { ...obj2 };
}).toThrow();
const KEY = Symbol('key');
const obj3Spread = { ...{ get foo () { return 'bar' } }, [KEY]: 'symbol' };
expect(Object.getOwnPropertyDescriptor(obj3Spread, 'foo').value).toBe('bar');
expect(Object.getOwnPropertyDescriptor(obj3Spread, KEY).value).toBe('symbol');
const obj4Spread = { ...Object.prototype };
expect(Object.getOwnPropertyDescriptor(obj4Spread, 'hasOwnProperty')).toBeUndefined();
expect(() => ({ ...null, ...undefined })).not.toThrow();
const o = Object.create(null);
o.a = 'foo';
o.__proto__ = [];
const o2 = { ...o };
// Loose will do o2.__proto__ = []
expect(Array.isArray(Object.getPrototypeOf(o2))).toBe(true);
"#
);
test!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
statements_for_of_dstr_obj_rest_to_property,
r#"
var src = {};
var counter = 0;
for ({ ...src.y } of [{ x: 1, y: 2 }]) {
expect(src.y.x).toEqual(1);
expect(src.y.y).toEqual(2);
counter += 1;
}
expect(counter).toEqual(1);
"#
);
test_exec!(
syntax(),
|_| tr(Config {
no_symbol: true,
set_property: true,
pure_getters: true
}),
statements_for_of_dstr_obj_rest_to_property_exec,
r#"
var src = {};
var counter = 0;
for ({ ...src.y } of [{ x: 1, y: 2 }]) {
expect(src.y.x).toEqual(1);
expect(src.y.y).toEqual(2);
counter += 1;
}
expect(counter).toEqual(1);
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
issue_4631,
r#"
let counter = 0
const b = {}
const a = {
...b,
get c() {
counter ++
}
}
expect(counter).toEqual(0);
a.c;a.c;
expect(counter).toEqual(2);
"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
issue_6029_1,
r#"
function thing({ queryKey: [{ url, ...query }] }) {
expect(url).toEqual('https://www.google.com')
expect(query).toEqual({ id: '1' })
}
thing({ queryKey: [{ url: 'https://www.google.com', id: '1' }] })
"#
);
test_exec!(
syntax(),
|t| {
//
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
tr(Default::default()),
es2015::es2015(
unresolved_mark,
Some(t.comments.clone()),
Default::default(),
),
)
},
issue_6029_2,
r#"
function thing({ queryKey: [{ url, ...query }] }) {
expect(url).toEqual('https://www.google.com')
expect(query).toEqual({ id: '1' })
}
thing({ queryKey: [{ url: 'https://www.google.com', id: '1' }] })
"#
);
compare_stdout!(
syntax(),
|_| {
//
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
tr(Default::default()),
)
},
issue_6988_1,
r###"
for (const a of [1,2,3]) {
const { ...rest } = {};
setTimeout(() => { console.log(a) });
}
"###
);
#[testing::fixture("tests/object-rest-spread/**/input.js")]
fn fixture(input: PathBuf) {
let parent = input.parent().unwrap();
let output = parent.join("output.js");
test_fixture(
Syntax::Es(Default::default()),
&|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
object_rest_spread(Default::default()),
)
},
&input,
&output,
Default::default(),
)
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2020_nullish_coalescing.rs | Rust | use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_compat::es2020::nullish_coalescing::{nullish_coalescing, Config};
use swc_ecma_transforms_testing::{compare_stdout, test, test_exec};
fn tr(c: Config) -> impl Pass {
nullish_coalescing(c)
}
fn syntax() -> Syntax {
Syntax::Es(Default::default())
}
test_exec!(
syntax(),
|_| tr(Default::default()),
runtime_semantics_exec,
r#"
expect(null ?? undefined).toBeUndefined(undefined);
expect(undefined ?? null).toBeNull();
expect(false ?? true).toBe(false);
expect(0 ?? 1).toBe(0);
expect("" ?? "foo").toBe("");
var obj = { exists: true };
expect(obj.exists ?? false).toBe(true);
expect(obj.doesNotExist ?? "foo").toBe("foo");
var counter = 0;
function sideEffect() { return counter++; }
expect(sideEffect() ?? -1).toBe(0);
var counter2 = 0;
var obj2 = {
get foo() { return counter2++; }
};
expect(obj2.foo ?? -1).toBe(0);
"#
);
test!(
syntax(),
|_| tr(Default::default()),
transform_in_default,
r#"
function foo(foo, qux = foo.bar ?? "qux") {}
"#
);
test!(
syntax(),
|_| tr(Default::default()),
transform_in_function,
r#"
function foo(opts) {
var foo = opts.foo ?? "default";
}
"#
);
test!(
syntax(),
|_| tr(Default::default()),
transform_static_refs_in_default,
r#"
function foo(foo, bar = foo ?? "bar") {}
"#
);
test!(
syntax(),
|_| tr(Default::default()),
transform_static_refs_in_function,
r#"
function foo() {
var foo = this ?? {};
}
"#
);
test!(
Default::default(),
|_| tr(Default::default()),
assign_01,
"
a ??= b;
"
);
test!(
Default::default(),
|_| tr(Default::default()),
issue_1570_1,
"
const a = {}
a.b ??= '1'
"
);
test_exec!(
Default::default(),
|_| tr(Default::default()),
issue_1570_2,
"
const a = {}
a.b ??= '1'
expect(a.b).toBe('1')
"
);
test!(
syntax(),
|_| tr(Config {
no_document_all: true
}),
loose,
r#"
function foo(opts) {
var foo = opts.foo ?? "default";
}
"#
);
test!(
syntax(),
|_| tr(Default::default()),
issue_6328,
"switch ( 0 ) { case 0 ?? 0 : }"
);
test!(
syntax(),
|_| tr(Default::default()),
issue_7290,
"
var filter = clone(initialFilter)
filter.start_point ??= {
location: null,
radius: null
}
filter.end_point ??= {
location: null,
radius: null
}
"
);
compare_stdout!(
syntax(),
|_| tr(Default::default()),
issue_7290_1,
"
var filter = {
start_point: 1
};
filter.start_point ??= {
location: null,
radius: null
}
filter.end_point ??= {
location: null,
radius: null
}
console.log(filter.start_point)
console.log(filter.end_point)
"
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2020_optional_chaining.rs | Rust | use std::{fs::read_to_string, path::PathBuf};
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2020::{optional_chaining, optional_chaining::Config},
es2022::class_properties,
};
use swc_ecma_transforms_testing::{compare_stdout, test, test_exec, test_fixture};
fn tr(c: Config) -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
optional_chaining(c, unresolved_mark),
)
}
fn syntax() -> Syntax {
Syntax::Typescript(Default::default())
}
// general_delete_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
general_delete_exec,
r#"
"use strict";
const obj = {
a: {
b: 0,
},
};
let test = delete obj?.a?.b;
expect(obj.a.b).toBeUndefined();
expect(test).toBe(true);
test = delete obj?.a.b;
expect(obj.a.b).toBeUndefined();
expect(test).toBe(true);
test = delete obj?.b?.b;
expect(obj.b).toBeUndefined();
expect(test).toBe(true);
delete obj?.a;
expect(obj.a).toBeUndefined();
"#
);
// general_unary_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
general_unary_exec,
r#"
"use strict";
const obj = {
a: {
b: 0,
},
};
let test = +obj?.a?.b;
expect(test).toBe(0);
test = +obj?.a.b;
expect(test).toBe(0);
test = +obj?.b?.b;
expect(test).toBe(NaN);
test = +obj?.b?.b;
expect(test).toBe(NaN);
"#
);
// general_call_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
general_call_exec,
r#"
"#
);
// regression_8354_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
regression_8354_exec,
r#"
const foo = undefined;
const bar = 'bar';
const foobar = foo?.replace(`foo${bar}`, '');
expect(foobar).toBe(undefined);
"#
);
// general_assignment_exec
test_exec!(
syntax(),
|_| tr(Default::default()),
general_assignment_exec,
r#"
"use strict";
const obj = {
a: {
b: {
c: {
d: 2,
},
},
},
};
const a = obj?.a;
expect(a).toBe(obj.a);
const b = obj?.a?.b;
expect(b).toBe(obj.a.b);
const bad = obj?.b?.b;
expect(bad).toBeUndefined();
let val;
val = obj?.a?.b;
expect(val).toBe(obj.a.b);
expect(() => {
const bad = obj?.b.b;
}).toThrow();
"#
);
test!(syntax(), |_| tr(Default::default()), simple_1, "obj?.a");
test!(syntax(), |_| tr(Default::default()), simple_2, "obj?.a?.b");
test_exec!(
syntax(),
|_| tr(Default::default()),
swc_node_95,
"
const obj = {
a: {
b: {
c: function () {
return this.foo
},
foo: 2,
},
foo: 1,
},
}
expect(obj?.a?.b?.c()).toBe(2)
"
);
test!(
syntax(),
|_| tr(Default::default()),
pr_2791,
r#"UNCONFIRMED_CALLBACK_MAP.get(pid)?.(error, response)"#
);
test_exec!(
syntax(),
|_| tr(Default::default()),
issue_6346,
"expect([1]?.filter(() => true).map?.(() => 2)).toEqual([2]);"
);
test_exec!(
ignore,
syntax(),
|_| tr(Config {
no_document_all: true,
pure_getter: true
}),
general_parenthesized_expression_member_call_loose,
r#"
class Foo {
constructor() {
this.x = 1;
this.self = this;
}
m() { return this.x; };
getSelf() { return this }
test() {
const Foo = this;
const o = { Foo: Foo };
const fn = function () {
return o;
};
expect((Foo?.["m"])()).toEqual(1);
expect((Foo?.["m"])().toString).toEqual(1..toString);
expect((Foo?.["m"])().toString()).toEqual('1');
expect(((Foo?.["m"]))()).toEqual(1);
expect(((Foo?.["m"]))().toString).toEqual(1..toString);
expect(((Foo?.["m"]))().toString()).toEqual('1');
expect((o?.Foo.m)()).toEqual(1);
expect((o?.Foo.m)().toString).toEqual(1..toString);
expect((o?.Foo.m)().toString()).toEqual('1');
expect((((o.Foo?.self.getSelf)())?.m)()).toEqual(1);
expect((((o.Foo.self?.getSelf)())?.m)()).toEqual(1);
expect((((fn()?.Foo?.self.getSelf)())?.m)()).toEqual(1);
expect((((fn?.().Foo.self?.getSelf)())?.m)()).toEqual(1);
}
testNull() {
const o = null;
expect(() => { (o?.Foo.m)() }).toThrow();
expect(() => { (o?.Foo.m)().toString }).toThrow();
expect(() => { (o?.Foo.m)().toString() }).toThrow();
expect(() => { (((o.Foo?.self.getSelf)())?.m)() }).toThrow();
expect(() => { (((o.Foo.self?.getSelf)())?.m)() }).toThrow();
expect(() => (((fn()?.Foo?.self.getSelf)())?.m)()).toThrow();
expect(() => (((fn?.().Foo.self?.getSelf)())?.m)()).toThrow();
}
}
(new Foo).test();
(new Foo).testNull();
"#
);
#[testing::fixture("tests/optional-chaining/**/exec.js")]
fn exec(input: PathBuf) {
let src = read_to_string(input).unwrap();
compare_stdout(
Default::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
optional_chaining(
Config {
no_document_all: true,
..Default::default()
},
Mark::new(),
),
)
},
&src,
);
}
#[testing::fixture("tests/optional-chaining/**/input.js")]
fn fixture(input: PathBuf) {
let output = input.with_file_name("output.js");
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
swc_ecma_transforms_compat::es2022::class_properties::Config {
private_as_properties: false,
..Default::default()
},
unresolved_mark,
),
optional_chaining(Default::default(), unresolved_mark),
)
},
&input,
&output,
Default::default(),
);
}
#[testing::fixture("tests/optional-chaining-loose/**/input.js")]
fn fixture_loose(input: PathBuf) {
let output = input.with_file_name("output.js");
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
swc_ecma_transforms_compat::es2022::class_properties::Config {
private_as_properties: false,
pure_getter: true,
no_document_all: true,
..Default::default()
},
unresolved_mark,
),
optional_chaining(
Config {
no_document_all: true,
pure_getter: true,
},
Mark::new(),
),
)
},
&input,
&output,
Default::default(),
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2021_logcal_assignments.rs | Rust | use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_compat::es2021;
use swc_ecma_transforms_testing::{test, test_exec};
fn tr() -> impl Pass {
es2021::logical_assignments()
}
fn syntax() -> Syntax {
Syntax::Typescript(Default::default())
}
test!(
syntax(),
|_| tr(),
logical_ident,
"
a ||= b
a &&= b
"
);
test!(
syntax(),
|_| tr(),
logical_member,
r#"
a.b ||= b
a.b &&= b
"#
);
test!(
syntax(),
|_| tr(),
logical_super,
"
class Foo {
method() {
return super.f ||= b
}
}
"
);
test!(syntax(), |_| tr(), nullish_ident, "a ??= b");
test!(syntax(), |_| tr(), nullish_member, "a.b ??= b");
test!(
syntax(),
|_| tr(),
issue_7169,
"function myFunc(options) {
options.context ||= {}
const closure = function() {}
}"
);
test_exec!(
syntax(),
|_| tr(),
null_coalescing,
"var x = undefined;
var sets = 0;
var obj = {
get x() {
return x;
},
set x(value) {
sets++;
x = value;
},
};
expect(obj.x ??= 1).toBe(1);
expect(sets).toBe(1);
expect(obj.x ??= 2).toBe(1);
expect(sets).toBe(1);
var gets = 0;
var deep = {
get obj() {
gets++;
return obj;
},
};
obj.x = undefined;
expect(deep.obj.x ??= 1).toBe(1);
expect(gets).toBe(1);
expect(deep.obj.x ??= 2).toBe(1);
expect(gets).toBe(2);
var key = 0;
obj.x = undefined;
expect(obj[++key] ??= 1).toBe(1);
expect(key).toBe(1);
key = 0;
expect(obj[++key] ??= 2).toBe(1);
expect(key).toBe(1);
obj.x = undefined;
key = 0;
expect(deep.obj[++key] ??= 1).toBe(1);
expect(gets).toBe(3);
expect(key).toBe(1);
key = 0;
expect(deep.obj[++key] ??= 2).toBe(1);
expect(gets).toBe(4);
expect(key).toBe(1);"
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2022_class_properties.rs | Rust | #![allow(deprecated)]
use std::{fs::read_to_string, path::PathBuf};
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015::{arrow, block_scoping, classes, function_name, template_literal},
es2016::exponentiation,
es2017::async_to_generator,
es2020::optional_chaining,
es2022::class_properties,
es3::reserved_words,
};
use swc_ecma_transforms_testing::{compare_stdout, test, test_exec, test_fixture, Tester};
fn syntax() -> Syntax {
Syntax::Es(Default::default())
}
fn tr(_: &Tester) -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
function_name(),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(unresolved_mark),
reserved_words(false),
)
}
test!(
syntax(),
|t| tr(t),
public_static_infer_name,
r#"
var Foo = class {
static num = 0;
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
public_call_exec,
r#"
class Foo {
foo = function() {
return this;
}
test(other) {
return [this.foo(), other.foo()];
}
}
const f = new Foo;
const o = new Foo;
const test = f.test(o);
expect(test[0]).toBe(f);
expect(test[1]).toBe(o);
"#
);
test!(
syntax(),
|t| tr(t),
public_instance_computed,
r#"
function test(x) {
class F {
[x] = 1;
constructor() {}
}
x = 'deadbeef';
expect(new F().foo).toBe(1);
x = 'wrong';
expect(new F().foo).toBe(1);
}
test('foo');
"#
);
test!(
syntax(),
|t| tr(t),
public_super_statement,
r#"
class Foo extends Bar {
bar = "foo";
constructor() {
super();
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
function_name(),
class_properties(Default::default(), unresolved_mark),
)
},
private_class_method,
r#"
class Foo {
#foo () {}
}
"#
);
test!(
syntax(),
|t| tr(t),
private_foobar,
r#"
class Child extends Parent {
constructor() {
super();
}
#scopedFunctionWithThis = () => {
this.name = {};
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_call_exec,
r#"
class Foo {
#foo = function() {
return this;
}
test(other) {
return [this.#foo(), other.#foo()];
}
}
const f = new Foo;
const o = new Foo;
const test = f.test(o);
expect(test[0]).toBe(f);
expect(test[1]).toBe(o);
"#
);
test!(
syntax(),
|t| tr(t),
public_derived_multiple_supers,
r#"
class Foo extends Bar {
bar = "foo";
constructor() {
if (condition) {
super();
} else {
super();
}
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_static_call_exec,
r#"
class Foo {
static #foo = function(x) {
return x;
}
test(x) {
return Foo.#foo(x);
}
}
const f = new Foo;
const test = f.test();
expect(f.test("bar")).toBe("bar");
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_instance_undefined_exec,
r#"
class Foo {
#bar;
test() {
return this.#bar;
}
}
expect(new Foo().test()).toBe(undefined);
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_instance_exec,
r#"
class Foo {
#bar = "foo";
test() {
return this.#bar;
}
update() {
this.#bar++;
}
set(val) {
this.#bar = val;
}
static test(foo) {
return foo.#bar;
}
static update(foo) {
foo.#bar **= 2;
}
}
const f = new Foo();
expect(f.test()).toBe("foo");
expect(Foo.test(f)).toBe("foo");
expect("bar" in f).toBe(false);
f.set(1);
expect(f.test()).toBe(1);
f.update();
expect(Foo.test(f)).toBe(2);
Foo.update(f);
expect(f.test()).toBe(4);
"#
);
test!(
syntax(),
|t| tr(t),
public_regression_t6719,
r#"
function withContext(ComposedComponent) {
return class WithContext extends Component {
static propTypes = {
context: PropTypes.shape(
{
addCss: PropTypes.func,
setTitle: PropTypes.func,
setMeta: PropTypes.func,
}
),
};
};
}
"#
);
test!(
syntax(),
|t| tr(t),
public_super_with_collision,
r#"
class A {
force = force;
foo = super.method();
constructor(force) {}
}
"#
);
test!(
syntax(),
|t| tr(t),
public_call,
r#"
class Foo {
foo = function() {
return this;
}
test(other) {
this.foo();
other.obj.foo();
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
public_instance_computed_exec,
r#"
function test(x) {
class F {
[x] = 1;
constructor() {}
}
x = 'deadbeef';
expect(new F().foo).toBe(1);
x = 'wrong';
expect(new F().foo).toBe(1);
}
test('foo');
"#
);
test!(
syntax(),
|t| tr(t),
private_declaration_order,
r#"
class C {
y = this.#x;
#x;
}
expect(() => {
new C();
}).toThrow();
"#
);
test!(
syntax(),
|t| tr(t),
nested_class_super_call_in_key,
r#"
class Hello {
constructor() {
return {
toString() {
return 'hello';
},
};
}
}
class Outer extends Hello {
constructor() {
class Inner {
[super()] = "hello";
}
return new Inner();
}
}
expect(new Outer().hello).toBe('hello');
"#
);
test!(
syntax(),
|t| tr(t),
public_instance_undefined,
r#"
class Foo {
bar;
}
"#
);
test!(
syntax(),
|t| tr(t),
private_derived_multiple_supers,
r#"
class Foo extends Bar {
#bar = "foo";
constructor() {
if (condition) {
super();
} else {
super();
}
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
public_native_classes_exec,
r#"
class Foo {
static foo = "foo";
bar = "bar";
static test() {
return Foo.foo;
}
test() {
return this.bar;
}
}
const f = new Foo();
expect("foo" in Foo).toBe(true)
expect("bar" in f).toBe(true)
expect(Foo.test()).toBe("foo")
expect(f.test()).toBe("bar")
"#
);
test!(
syntax(),
|t| tr(t),
public_regression_t2983,
r#"
call(class {
static test = true
});
export default class {
static test = true
}
"#
);
test!(
syntax(),
|t| tr(t),
public_static,
r#"
class Foo {
static bar = "foo";
}
"#
);
test!(
syntax(),
|t| tr(t),
private_instance_undefined,
r#"
class Foo {
#bar;
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_declaration_order_exec,
r#"
class C {
y = this.#x;
#x;
}
expect(() => {
new C();
}).toThrow();
"#
);
test!(
syntax(),
|t| tr(t),
public_update,
r#"
class Foo {
foo = 0;
test(other) {
this.foo++;
++this.foo;
other.obj.foo++;
++other.obj.foo;
}
}
"#
);
test!(
syntax(),
|t| tr(t),
public_super_call,
r#"
class A {
foo() {
return "bar";
}
}
class B extends A {
foo = super.foo();
}
"#
);
test!(
syntax(),
|t| tr(t),
private_constructor_collision,
r#"
var foo = "bar";
class Foo {
#bar = foo;
constructor() {
var foo = "foo";
}
}
"#
);
test!(
syntax(),
|t| tr(t),
public_constructor_collision,
r#"
var foo = "bar";
class Foo {
bar = foo;
static bar = baz;
constructor() {
var foo = "foo";
var baz = "baz";
}
}
"#
);
test!(
syntax(),
|t| tr(t),
public_computed,
r#"
const foo = "foo";
const bar = () => {};
const four = 4;
class MyClass {
static [one()] = "test";
static [2 * 4 + 7] = "247";
static [2 * four + 7] = "247";
static [2 * four + seven] = "247";
[null] = "null";
[undefined] = "undefined";
[void 0] = "void 0";
get ["whatever"]() {}
set ["whatever"](value) {}
get [computed()]() {}
set [computed()](value) {}
["test" + one]() {}
static [10]() {}
[/regex/] = "regex";
[foo] = "foo";
[bar] = "bar";
[baz] = "baz";
[`template`] = "template";
[`template${expression}`] = "template-with-expression";
}
"#
);
test!(
syntax(),
|t| tr(t),
public_assignment,
r#"
class Foo {
foo = 0;
test(other) {
this.foo++;
this.foo += 1;
this.foo = 2;
other.obj.foo++;
other.obj.foo += 1;
other.obj.foo = 2;
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
public_static_exec,
r#"
class Foo {
static num = 0;
static str = "foo";
}
expect(Foo.num).toBe(0);
expect(Foo.num = 1).toBe(1);
expect(Foo.str).toBe("foo");
expect(Foo.str = "bar").toBe("bar");
"#
);
test_exec!(
syntax(),
|t| tr(t),
regression_7371_exec_1,
r#"
class C {
}
class A extends C {
field = 1;
constructor() {
super();
class B extends C {
constructor() {
super();
expect(this.field).toBeUndefined();
}
}
expect(this.field).toBe(1)
new B();
}
}
new A();
"#
);
test_exec!(
syntax(),
|t| tr(t),
regression_7371_exec_2,
r#"
class Obj {
constructor() {
return {};
}
}
// ensure superClass is still transformed
class SuperClass extends Obj {
field = 1;
constructor() {
class B extends (super(), Obj) {
constructor() {
super();
expect(this.field).toBeUndefined()
}
}
expect(this.field).toBe(1)
new B();
}
}
new SuperClass();
// ensure ComputedKey Method is still transformed
class ComputedMethod extends Obj {
field = 1;
constructor() {
class B extends Obj {
constructor() {
super();
expect(this.field).toBeUndefined()
}
[super()]() { }
}
expect(this.field).toBe(1)
new B();
}
}
new ComputedMethod();
// ensure ComputedKey Field is still transformed
class ComputedField extends Obj {
field = 1;
constructor() {
class B extends Obj {
constructor() {
super();
expect(this.field).toBeUndefined()
}
[super()] = 1;
}
expect(this.field).toBe(1)
new B();
}
}
new ComputedField();
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_static_inherited_exec,
r#"
class Base {
static #foo = 1;
static getThis() {
return this.#foo;
}
static updateThis(val) {
return (this.#foo = val);
}
static getClass() {
return Base.#foo;
}
static updateClass(val) {
return (Base.#foo = val);
}
}
class Sub1 extends Base {
static #foo = 2;
static update(val) {
return (this.#foo = val);
}
}
class Sub2 extends Base {}
expect(Base.getThis()).toBe(1);
expect(Base.getClass()).toBe(1);
expect(() => Sub1.getThis()).toThrow();
expect(Sub1.getClass()).toBe(1);
expect(() => Sub2.getThis()).toThrow();
expect(Sub2.getClass()).toBe(1);
expect(Sub1.update(3)).toBe(3);
expect(Base.getThis()).toBe(1);
expect(Base.getClass()).toBe(1);
expect(() => Sub1.getThis()).toThrow();
expect(Sub1.getClass()).toBe(1);
expect(() => Sub2.getThis()).toThrow();
expect(Sub2.getClass()).toBe(1);
expect(Base.updateThis(4)).toBe(4);
expect(Base.getThis()).toBe(4);
expect(Base.getClass()).toBe(4);
expect(() => Sub1.getThis()).toThrow();
expect(Sub1.getClass()).toBe(4);
expect(() => Sub2.getThis()).toThrow();
expect(Sub2.getClass()).toBe(4);
expect(Base.updateClass(5)).toBe(5);
expect(Base.getThis()).toBe(5);
expect(Base.getClass()).toBe(5);
expect(() => Sub1.getThis()).toThrow();
expect(Sub1.getClass()).toBe(5);
expect(() => Sub2.getThis()).toThrow();
expect(Sub2.getClass()).toBe(5);
expect(() => Sub2.updateThis(6)).toThrow();
expect(Sub2.updateClass(7)).toBe(7);
expect(Base.getThis()).toBe(7);
expect(Base.getClass()).toBe(7);
expect(() => Sub1.getThis()).toThrow();
expect(Sub1.getClass()).toBe(7);
expect(() => Sub2.getThis()).toThrow();
expect(Sub2.getClass()).toBe(7);
"#
);
test_exec!(
syntax(),
|t| tr(t),
nested_class_super_property_in_key_exec,
r#"
class Hello {
toString() {
return 'hello';
}
}
class Outer extends Hello {
constructor() {
super();
class Inner {
[super.toString()] = 'hello';
}
return new Inner();
}
}
expect(new Outer().hello).toBe('hello');
"#
);
test!(
syntax(),
|t| tr(t),
private_super_statement,
r#"
class Foo extends Bar {
#bar = "foo";
constructor() {
super();
}
}
"#
);
test!(
syntax(),
|t| tr(t),
private_private_in_derived,
r#"
class Outer {
#outer;
constructor() {
class Test extends this.#outer {
}
}
}
"#
);
test!(
syntax(),
|t| tr(t),
private_update,
r#"
class Foo {
#foo = 0;
test(other) {
this.#foo++;
++this.#foo;
other.obj.#foo++;
++other.obj.#foo;
}
}
"#
);
test!(
syntax(),
|t| tr(t),
public_super_expression,
r#"
class Foo extends Bar {
bar = "foo";
constructor() {
foo(super());
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
public_computed_initialization_order_exec,
r#"
const actualOrder = [];
const track = i => {
actualOrder.push(i);
return i;
};
class MyClass {
static [track(1)] = track(10);
[track(2)] = track(13);
get [track(3)]() {
return "foo";
}
set [track(4)](value) {
this.bar = value;
}
[track(5)] = track(14);
static [track(6)] = track(11);
static [track(7)] = track(12);
[track(8)]() {}
[track(9)] = track(15);
}
const inst = new MyClass();
const expectedOrder = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
expect(actualOrder).toEqual(expectedOrder);
expect(MyClass[1]).toBe(10);
expect(inst[2]).toBe(13);
expect(inst[3]).toBe("foo");
inst[4] = "baz";
expect(inst.bar).toBe("baz");
expect(inst[5]).toBe(14);
expect(MyClass[6]).toBe(11);
expect(MyClass[7]).toBe(12);
expect(typeof inst[8]).toBe("function");
expect(inst[9]).toBe(15);
"#
);
test_exec!(
syntax(),
|t| tr(t),
nested_class_super_call_in_key_exec,
r#"
class Hello {
constructor() {
return {
toString() {
return 'hello';
},
};
}
}
class Outer extends Hello {
constructor() {
class Inner {
[super()] = "hello";
}
return new Inner();
}
}
expect(new Outer().hello).toBe('hello');
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_update_exec,
r#"
class Foo {
#foo = 0;
test(other) {
return [
this.#foo++,
this.#foo,
++this.#foo,
this.#foo,
other.obj.#foo++,
other.obj.#foo,
++other.obj.#foo,
other.obj.#foo,
];
}
}
const f = new Foo;
const results = f.test({ obj: f });
expect(results[0]).toBe(0);
expect(results[1]).toBe(1);
expect(results[2]).toBe(2);
expect(results[3]).toBe(2);
expect(results[4]).toBe(2);
expect(results[5]).toBe(3);
expect(results[6]).toBe(4);
expect(results[7]).toBe(4);
"#
);
test!(
syntax(),
|t| tr(t),
public_extracted_this,
r#"
var foo = "bar";
class Foo {
bar = this;
baz = foo;
constructor(foo) {
}
}
"#
);
test!(
syntax(),
|t| tr(t),
private_derived,
r#"
class Foo {
#prop = "foo";
}
class Bar extends Foo {
#prop = "bar";
}
"#
);
test!(
syntax(),
|t| tr(t),
private_super_call,
r#"
class A {
foo() {
return "bar";
}
}
class B extends A {
#foo = super.foo();
}
"#
);
test!(
syntax(),
|t| tr(t),
private_reference_in_other_property,
r#"
class Foo {
one = this.#private;
#two = this.#private;
#private = 0;
three = this.#private;
#four = this.#private;
}
"#
);
test!(
syntax(),
|t| tr(t),
nested_class_super_property_in_key,
r#"
class Hello {
toString() {
return 'hello';
}
}
class Outer extends Hello {
constructor() {
super();
class Inner {
[super.toString()] = 'hello';
}
return new Inner();
}
}
expect(new Outer().hello).toBe('hello');
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_reevaluated_exec,
r#"
function classFactory() {
return class Foo {
#foo = "foo";
static #bar = "bar";
instance() {
return this.#foo;
}
static() {
return Foo.#bar;
}
static instance(inst) {
return inst.#foo;
}
static static() {
return Foo.#bar;
}
};
}
const Foo1 = classFactory();
const Foo2 = classFactory();
const f1 = new Foo1();
const f2 = new Foo2();
expect(f1.instance()).toBe("foo");
expect(f1.static()).toBe("bar");
expect(f2.instance()).toBe("foo");
expect(f2.static()).toBe("bar");
expect(Foo1.instance(f1)).toBe("foo");
expect(Foo1.static()).toBe("bar");
expect(Foo2.instance(f2)).toBe("foo");
expect(Foo2.static()).toBe("bar");
expect(() => {
f1.instance.call(f2), undefined;
}).toThrow();
expect(() => {
f2.instance.call(f1), undefined;
}).toThrow();
expect(() => {
Foo1.instance(f2), undefined;
}).toThrow();
expect(() => {
Foo2.instance(f1), undefined;
}).toThrow();
"#
);
test!(
syntax(),
|t| tr(t),
public_numeric,
r#"
class Foo {
0 = "foo";
1 = "bar";
}
"#
);
test!(
syntax(),
|t| tr(t),
private_assignment,
r#"
class Foo {
#foo = 0;
test(other) {
this.#foo += 1;
this.#foo = 2;
other.obj.#foo += 1;
other.obj.#foo = 2;
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_constructor_collision_exec,
r#"
var foo = "bar";
class Foo {
#bar = foo;
constructor() {
var foo = "foo";
}
test() {
return this.#bar;
}
}
const f = new Foo;
expect(f.test()).toBe(foo);
expect("bar" in f).toBe(false);
"#
);
test!(
syntax(),
|t| tr(t),
public_static_export,
r#"
export class MyClass {
static property = value;
}
export default class MyClass2 {
static property = value;
}
"#
);
test!(
syntax(),
|t| tr(t),
private_multiple,
r#"
class Foo {
#x = 0;
#y = this.#x;
}
"#
);
test!(
syntax(),
|t| tr(t),
public_derived,
r#"
class Foo extends Bar {
bar = "foo";
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
public_static_undefined_exec,
r#"
class Foo {
static num;
}
expect("num" in Foo).toBe(true);
expect(Foo.num).toBeUndefined();
"#
);
test!(
syntax(),
|t| tr(t),
public_instance,
r#"
class Foo {
bar = "foo";
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
static_property_tdz_edgest_case_exec,
r#"
expect(() => {
class A {
static [{ x: A || 0 }.x];
}
}).toThrow();
"#
);
test!(
syntax(),
|t| tr(t),
public_non_block_arrow_func,
r#"
export default param =>
class App {
static props = {
prop1: 'prop1',
prop2: 'prop2'
}
getParam() {
return param;
}
}
"#
);
test!(
syntax(),
|t| tr(t),
public_static_undefined,
r#"
class Foo {
static bar;
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
public_static_infer_name_exec,
r#"
var Foo = class {
static num = 0;
}
expect(Foo.num).toBe(0);
expect(Foo.num = 1).toBe(1);
expect(Foo.name).toBe("Foo");
"#
);
test_exec!(
syntax(),
|t| tr(t),
static_property_tdz_general_exec,
r#"
expect(() => {
class C {
static [C + 3] = 3;
}
}).toThrow();
"#
);
test!(
syntax(),
|t| tr(t),
private_call,
r#"
class Foo {
#foo = function() {
return this;
}
test(other) {
this.#foo();
other.obj.#foo();
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_derived_exec,
r#"
class Foo {
#prop = "foo";
foo() {
return this.#prop;
}
}
class Bar extends Foo {
#prop = "bar";
bar() {
return this.#prop;
}
}
const f = new Foo;
expect(f.foo()).toBe("foo");
const b = new Bar;
expect(b.foo()).toBe("foo");
expect(b.bar()).toBe("bar");
"#
);
test!(
syntax(),
|t| tr(t),
private_extracted_this,
r#"
var foo = "bar";
class Foo {
#bar = this;
#baz = foo;
constructor(foo) {
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_canonical_exec,
r#"
class Point {
#x;
#y;
constructor(x = 0, y = 0) {
this.#x = +x;
this.#y = +y;
}
get x() { return this.#x }
set x(value) { this.#x = +value }
get y() { return this.#y }
set y(value) { this.#y = +value }
equals(p) { return this.#x === p.#x && this.#y === p.#y }
toString() { return `Point<${ this.#x },${ this.#y }>` }
}
const p1 = new Point(1, 2);
const p2 = new Point(2, 3);
const p3 = new Point(1, 2);
expect(p1.x).toBe(1);
expect(p1.y).toBe(2);
expect(p2.x).toBe(2);
expect(p2.y).toBe(3);
expect(p3.x).toBe(1);
expect(p3.y).toBe(2);
expect(p1.equals(p1)).toBe(true)
expect(p1.equals(p2)).toBe(false)
expect(p1.equals(p3)).toBe(true)
expect(p2.equals(p1)).toBe(false)
expect(p2.equals(p2)).toBe(true)
expect(p2.equals(p3)).toBe(false)
expect(p3.equals(p1)).toBe(true)
expect(p3.equals(p2)).toBe(false)
expect(p3.equals(p3)).toBe(true)
expect(p1.toString()).toBe("Point<1,2>")
expect(p2.toString()).toBe("Point<2,3>")
expect(p3.toString()).toBe("Point<1,2>")
p1.x += 1;
p1.y = 3;
p2.x -= 1;
p2.y = 3;
p3.x = 0;
p3.y = 0;
expect(p1.x).toBe(2);
expect(p1.y).toBe(3);
expect(p2.x).toBe(1);
expect(p2.y).toBe(3);
expect(p3.x).toBe(0);
expect(p3.y).toBe(0);
expect(p1.equals(p1)).toBe(true)
expect(p1.equals(p2)).toBe(false)
expect(p1.equals(p3)).toBe(false)
expect(p2.equals(p1)).toBe(false)
expect(p2.equals(p2)).toBe(true)
expect(p2.equals(p3)).toBe(false)
expect(p3.equals(p1)).toBe(false)
expect(p3.equals(p2)).toBe(false)
expect(p3.equals(p3)).toBe(true)
expect(p1.toString()).toBe("Point<2,3>")
expect(p2.toString()).toBe("Point<1,3>")
expect(p3.toString()).toBe("Point<0,0>")
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_static_undefined_exec,
r#"
class Foo {
static #bar;
static test() {
return Foo.#bar;
}
test() {
return Foo.#bar;
}
}
expect("bar" in Foo).toBe(false);
expect(Foo.test()).toBe(undefined);
expect(Foo.test()).toBe(undefined);
"#
);
test_exec!(
syntax(),
|t| tr(t),
public_update_exec,
r#"
class Foo {
foo = 0;
test(other) {
return [
this.foo++,
this.foo,
++this.foo,
this.foo,
other.obj.foo++,
other.obj.foo,
++other.obj.foo,
other.obj.foo,
];
}
}
const f = new Foo;
const results = f.test({ obj: f });
expect(results[0]).toBe(0);
expect(results[1]).toBe(1);
expect(results[2]).toBe(2);
expect(results[3]).toBe(2);
expect(results[4]).toBe(2);
expect(results[5]).toBe(3);
expect(results[6]).toBe(4);
expect(results[7]).toBe(4);
"#
);
test!(
syntax(),
|t| tr(t),
private_static_call,
r#"
class Foo {
static #foo = function(x) {
return x;
}
test(x) {
return Foo.#foo(x);
}
}
"#
);
test!(
syntax(),
|t| tr(t),
private_super_expression,
r#"
class Foo extends Bar {
#bar = "foo";
constructor() {
foo(super());
}
}
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_native_classes_exec,
r#"
class Foo {
static #foo = "foo";
#bar = "bar";
static test() {
return Foo.#foo;
}
test() {
return this.#bar;
}
}
const f = new Foo();
expect("foo" in Foo).toBe(false)
expect("bar" in f).toBe(false)
expect(Foo.test()).toBe("foo")
expect(f.test()).toBe("bar")
"#
);
test_exec!(
syntax(),
|t| tr(t),
private_multiple_exec,
r#"
class Foo {
#x = 0;
#y = this.#x + 1;
test() {
return this.#y;
}
}
const f = new Foo();
expect(f.test()).toBe(1);
"#
);
test!(
syntax(),
|t| tr(t),
custom_instance_update,
"
class Foo {
#x = 0;
test() {
this.#x++;
++this.#x;
}
}
"
);
test!(
syntax(),
|t| tr(t),
custom_static_update,
"
class Foo {
static #x = 0;
test() {
Foo.#x++;
++Foo.#x;
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
)
},
issue_308,
"function bar(props) {}
class Foo {
constructor() {
super();
bar();
}
onBar = () => {
bar();
};
}"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
)
},
issue_342,
"class Foo {
constructor(bar) {
this._bar = bar;
}
qux = {
frob: (bar) => {},
};
}"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
block_scoping(unresolved_mark),
)
},
issue_443,
"
const MODE = 1;
class foo {
static MODE = MODE;
constructor() {
this.mode = MODE;
}
}
"
);
// public_regression_t7364
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), Mark::new()),
)
},
public_regression_t7364,
r#"
class MyClass {
myAsyncMethod = async () => {
console.log(this);
}
}
(class MyClass2 {
myAsyncMethod = async () => {
console.log(this);
}
})
export default class MyClass3 {
myAsyncMethod = async () => {
console.log(this);
}
}
"#
);
// private_regression_t6719
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_regression_t6719,
r#"
function withContext(ComposedComponent) {
return class WithContext extends Component {
static #propTypes = {
context: PropTypes.shape(
{
addCss: PropTypes.func,
setTitle: PropTypes.func,
setMeta: PropTypes.func,
}
),
};
};
}
"#
);
// private_reevaluated
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_reevaluated,
r#"
function classFactory() {
return class Foo {
#foo = "foo";
static #bar = "bar";
instance() {
return this.#foo;
}
static() {
return Foo.#bar;
}
static instance(inst) {
return inst.#foo;
}
static static() {
return Foo.#bar;
}
};
}
"#
);
// private_static
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_static,
r#"
class Foo {
static #bar = "foo";
static test() {
return Foo.#bar;
}
test() {
return Foo.#bar;
}
}
expect("bar" in Foo).toBe(false)
expect(Foo.test()).toBe("foo")
expect(Foo.test()).toBe("foo")
"#
);
// private_destructuring_object_pattern_1
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
private_destructuring_object_pattern_1,
r#"
class Foo {
#client
constructor(props) {
this.#client = 'foo';
({ x: this.x = this.#client, y: this.#client, z: this.z = this.#client } = props)
}
}
"#
);
// private_static_inherited
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_static_inherited,
r#"
class Base {
static #foo = 1;
static getThis() {
return this.#foo;
}
static updateThis(val) {
return (this.#foo = val);
}
static getClass() {
return Base.#foo;
}
static updateClass(val) {
return (Base.#foo = val);
}
}
class Sub1 extends Base {
static #foo = 2;
static update(val) {
return (this.#foo = val);
}
}
class Sub2 extends Base {}
"#
);
// private_destructuring_object_pattern_1_exec
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
private_destructuring_object_pattern_1_exec,
r#"
class Foo {
#client
constructor(props) {
this.#client = 'foo';
;({ x: this.x = this.#client, y: this.#client, z: this.z = this.#client } = props)
}
getClient() {
return this.#client;
}
}
const foo = new Foo({ y: 'bar' });
expect(foo.getClient()).toBe('bar');
expect(foo.x).toBe('foo');
expect(foo.z).toBe('bar');
"#
);
// private_static_undefined
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_static_undefined,
r#"
class Foo {
static #bar;
static test() {
return Foo.#bar;
}
test() {
return Foo.#bar;
}
}
"#
);
// private_destructuring_array_pattern
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
private_destructuring_array_pattern,
r#"
class Foo {
#client
constructor(props) {
([this.#client] = props);
}
}
"#
);
// private_regression_t2983
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_regression_t2983,
r#"
call(class {
static #test = true
});
export default class {
static #test = true
}
"#
);
// private_regression_t7364
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), unresolved_mark),
block_scoping(unresolved_mark),
)
},
private_regression_t7364,
r#"
class MyClass {
#myAsyncMethod = async () => {
console.log(this);
}
}
(class MyClass2 {
#myAsyncMethod = async () => {
console.log(this);
}
})
export default class MyClass3 {
#myAsyncMethod = async () => {
console.log(this);
}
}
"#
);
// private_destructuring_array_pattern_1
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
private_destructuring_array_pattern_1,
r#"
class Foo {
#client
constructor(props) {
this.#client = 1;
([this.x = this.#client, this.#client, this.y = this.#client] = props);
}
}
"#
);
// regression_8882_exec
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
regression_8882_exec,
r#"
const classes = [];
for (let i = 0; i <= 10; ++i) {
classes.push(
class A {
[i] = `computed field ${i}`;
static foo = `static field ${i}`;
#bar = `private field ${i}`;
getBar() {
return this.#bar;
}
}
);
}
for(let i=0; i<= 10; ++i) {
const clazz = classes[i];
expect(clazz.foo).toBe('static field ' + i);
const instance = new clazz();
expect(Object.getOwnPropertyNames(instance)).toEqual([String(i)])
expect(instance[i]).toBe('computed field ' + i);
expect(instance.getBar()).toBe('private field ' + i);
}
"#
);
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
regression_8882_exec_2,
r#"
const classes = [];
for (let i = 0; i <= 10; ++i) {
class A {
[i] = `computed field ${i}`;
static foo = `static field ${i}`;
#bar = `private field ${i}`;
getBar() {
return this.#bar;
}
}
classes.push(A)
}
for(let i=0; i<= 10; ++i) {
const clazz = classes[i];
expect(clazz.foo).toBe('static field ' + i);
const instance = new clazz();
expect(Object.getOwnPropertyNames(instance)).toEqual([String(i)])
expect(instance[i]).toBe('computed field ' + i);
expect(instance.getBar()).toBe('private field ' + i);
}
"#
);
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
private_field_reinitialized,
r#"
class Base {
constructor(obj) {
return obj;
}
}
class Derived extends Base {
#c = 123
}
const foo = {}
new Derived(foo)
expect(() => new Derived(foo)).toThrow()
"#
);
// private_static_export
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_static_export,
r#"
export class MyClass {
static #property = value;
}
export default class MyClass2 {
static #property = value;
}
"#
);
// static_property_tdz_edgest_case
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
)
},
static_property_tdz_edgest_case,
r#"
class A {
static [{ x: A || 0 }.x];
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
)
},
static_property_tdz_false_alarm,
r#"
class A {
static A = 123;
}
"#
);
// regression_6153
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
arrow(Mark::new()),
)
},
regression_6153,
r#"
() => {
class Foo {
fn = () => console.log(this);
static fn = () => console.log(this);
}
};
() => class Bar {
fn = () => console.log(this);
static fn = () => console.log(this);
};
() => {
class Baz {
fn = () => console.log(this);
force = force
static fn = () => console.log(this);
constructor(force) {}
}
};
var qux = function() {
class Qux {
fn = () => console.log(this);
static fn = () => console.log(this);
}
}.bind(this)
"#
);
// regression_7371
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
arrow(unresolved_mark),
)
},
regression_7371,
r#"
"use strict";
class C {
}
class A extends C {
field = 1;
constructor() {
super();
class B extends C {
constructor() {
super();
expect(this.field).toBeUndefined();
}
}
expect(this.field).toBe(1)
new B();
}
}
new A();
class Obj {
constructor() {
return {};
}
}
// ensure superClass is still transformed
class SuperClass extends Obj {
field = 1;
constructor() {
class B extends (super(), Obj) {
constructor() {
super();
expect(this.field).toBeUndefined()
}
}
expect(this.field).toBe(1)
new B();
}
}
new SuperClass();
// ensure ComputedKey Method is still transformed
class ComputedMethod extends Obj {
field = 1;
constructor() {
class B extends Obj {
constructor() {
super();
expect(this.field).toBeUndefined()
}
[super()]() { }
}
expect(this.field).toBe(1)
new B();
}
}
new ComputedMethod();
// ensure ComputedKey Field is still transformed
class ComputedField extends Obj {
field = 1;
constructor() {
class B extends Obj {
constructor() {
super();
expect(this.field).toBeUndefined()
}
[super()] = 1;
}
expect(this.field).toBe(1)
new B();
}
}
new ComputedField();
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
private_optional_chain_call,
r#"
class A {
#fieldFunc;
x = 1;
test() {
this.#fieldFunc?.();
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
private_optional_chain_member,
r#"
class MyClass {
#a
foo(o) {
o?.#a
}
}
"#
);
// private_canonical
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
private_canonical,
r#"
class Point {
#x;
#y;
constructor(x = 0, y = 0) {
this.#x = +x;
this.#y = +y;
}
get x() { return this.#x }
set x(value) { this.#x = +value }
get y() { return this.#y }
set y(value) { this.#y = +value }
equals(p) { return this.#x === p.#x && this.#y === p.#y }
toString() { return `Point<${ this.#x },${ this.#y }>` }
}
"#
);
// regression_8882
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
regression_8882,
r#"
const classes = [];
for(let i = 0; i <= 10; ++i){
classes.push(function() {
class A{
getBar() {
return _class_private_field_get(this, _bar);
}
constructor(){
_define_property(this, i, `computed field ${i}`);
_bar.set(this, {
writable: true,
value: `private field ${i}`
});
}
}
_define_property(A, 'foo', `static field ${i}`);
var _bar = new WeakMap();
return A;
}());
}
"#
);
// private_destructuring_array_pattern_3
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
private_destructuring_array_pattern_3,
r#"
class Foo {
#client
constructor(props) {
([this.#client = 5] = props);
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
staic_private_destructuring_array_pattern,
r#"
class A {
#a = 123
foo() {
[a().#a] = []
}
}
"#
);
// public_static_super_exec
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
public_static_super_exec,
r#"
class A {
static prop = 1;
}
class B extends A {
static prop = 2;
static propA = super.prop;
static getPropA = () => super.prop;
}
const { prop, propA, getPropA } = B;
expect(prop).toBe(2);
expect(propA).toBe(1);
expect(getPropA()).toBe(1);
"#
);
// private_destructuring_array_pattern_2
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
private_destructuring_array_pattern_2,
r#"
class Foo {
#client
constructor(props) {
([x, ...this.#client] = props);
}
}
"#
);
// private_non_block_arrow_func
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_non_block_arrow_func,
r#"
export default param =>
class App {
static #props = {
prop1: 'prop1',
prop2: 'prop2'
}
getParam() {
return param;
}
}
"#
);
// regression_8110
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
regression_8110,
r#"
const field = Symbol('field');
class A {
[field] = 10;
}
"#
);
// public_computed_without_block_exec
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
public_computed_without_block_exec,
r#"
const createClass = (k) => class { [k()] = 2 };
const clazz = createClass(() => 'foo');
const instance = new clazz();
expect(instance.foo).toBe(2);
"#
);
// private_instance
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
exponentiation(),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
private_instance,
r#"
class Foo {
#bar = "foo";
}
"#
);
// static_property_tdz_general
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
)
},
static_property_tdz_general,
r#"
class C {
static [C + 3] = 3;
}
"#
);
// public_native_classes
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
public_native_classes,
r#"
class Foo {
static foo = "foo";
bar = "bar";
}
"#
);
// public_arrow_static_this_without_transform
test!(
// Emitting class properties is not supported yet.
syntax(),
|_| arrow(Mark::new()),
public_arrow_static_this_without_transform,
r#"
class Foo {
static fn = () => console.log(this);
}
"#
);
// private_static_infer_name
test!(
// Seems useless, while being hard to implement.
ignore,
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_static_infer_name,
r#"
var Foo = class {
static #num = 0;
}
"#
);
// regression_7951
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
)
},
regression_7951,
r#"
export class Foo extends Bar {
static foo = {};
test = args;
}
"#
);
// private_native_classes
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
block_scoping(Mark::new()),
)
},
private_native_classes,
r#"
class Foo {
static #foo = "foo";
#bar = "bar";
static test() {
return Foo.#foo;
}
test() {
return this.#bar;
}
}
"#
);
// public_computed_without_block
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
public_computed_without_block,
r#"
const createClass = (k) => class { [k()] = 2 };
"#
);
// private_destructuring_array_pattern_2_exec
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
private_destructuring_array_pattern_2_exec,
r#"
class Foo {
#client
constructor(props) {
let x;
;([x, ...this.#client] = props);
}
getClient() {
return this.#client;
}
}
const foo = new Foo(['foo', 'bar', 'baz', 'quu']);
expect(foo.getClient()).toEqual(['bar', 'baz', 'quu']);
"#
);
// public_static_super
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
classes(Default::default()),
block_scoping(Mark::new()),
)
},
public_static_super,
r#"
class A {
static prop = 1;
}
class B extends A {
static prop = 2;
static propA = super.prop;
static getPropA = () => super.prop;
}
"#
);
// private_destructuring_array_pattern_exec
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
private_destructuring_array_pattern_exec,
r#"
class Foo {
#client
constructor(props) {
;([this.#client] = props);
}
getClient() {
return this.#client;
}
}
const foo = new Foo(['bar']);
expect(foo.getClient()).toBe('bar');
"#
);
// private_destructuring_array_pattern_1_exec
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
private_destructuring_array_pattern_1_exec,
r#"
class Foo {
#client
constructor(props) {
this.#client = 1;
;([this.x = this.#client, this.#client, this.y = this.#client] = props);
}
getClient() {
return this.#client;
}
}
const foo = new Foo([undefined, 'bar']);
expect(foo.getClient()).toBe('bar');
expect(foo.x).toBe(1);
expect(foo.y).toBe('bar');
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1306_1,
r#"
class Animal {
#name;
constructor(name) {
this.#name = name
}
noise() {
return this.#name
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1306_2,
r#"
class Animal {
#name;
constructor(name) {
this.#name = name
}
noise() {
return this.#name.toUpperCase()
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1333_1,
"
class Foo {
#ws;
#ws2;
get connected() {
return this.#ws2 && this.#ws.readyState === _ws1.default.OPEN;
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1333_2,
"
class Test {
#ws;
#serialization;
#seq;
_packet(raw) {
/** @type {DiscordPacket} */
let pak;
try {
pak = this.#serialization.decode(raw);
this.manager.emit(ClientEvent.RAW_PACKET, pak, this);
} catch (e) {
this.manager.client.emit(ClientEvent.SHARD_ERROR, e, this);
return;
}
switch (pak.t) {
case 'READY':
this.emit(ShardEvent.READY);
this.session.id = pak.d.session_id;
this.expectedGuilds = new Set(pak.d.guilds.map((g) => g.id));
this.status = Status.WAITING_FOR_GUILDS;
this.heartbeat.acked = true;
this.heartbeat.new('ready');
break;
case 'RESUMED':
/**
* Emitted when a shards connection has been resumed.
* @event Shard#resumed
*/
this.emit(ShardEvent.RESUMED);
this.status = Status.READY;
this.heartbeat.acked = true;
this.heartbeat.new('resumed');
break;
}
if (pak.s !== null) {
if (this.#seq !== -1 && pak.s > this.#seq + 1) {
this._debug(`Non-consecutive sequence [${this.#seq} => ${pak.s}]`);
}
this.#seq = pak.s;
}
switch (pak.op) {
case GatewayOp.HELLO:
this.heartbeat.delay = pak.d.heartbeat_interval;
this.session.hello();
break;
case GatewayOp.RECONNECT:
this._debug('Gateway asked us to reconnect.');
this.destroy({ code: 4000 });
break;
case GatewayOp.INVALID_SESSION:
this._debug(`Invalid Session: Resumable => ${pak.d}`);
if (pak.d) {
this.session.resume();
break;
}
this.#seq = -1;
this.session.reset();
this.status = Status.RECONNECTING;
this.emit(ShardEvent.INVALID_SESSION);
break;
case GatewayOp.HEARTBEAT:
this.heartbeat.new('requested');
break;
case GatewayOp.HEARTBEAT_ACK:
this.heartbeat.ack();
break;
default:
if (
this.status === Status.WAITING_FOR_GUILDS &&
pak.t === 'GUILD_CREATE'
) {
this.expectedGuilds.delete(pak.d.id);
this._checkReady();
}
}
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1333_3,
"
class Test {
#ws;
#serialization;
_packet(raw) {
/** @type {DiscordPacket} */
let pak;
try {
pak = this.#serialization.decode(raw);
this.manager.emit(ClientEvent.RAW_PACKET, pak, this);
} catch (e) {
this.manager.client.emit(ClientEvent.SHARD_ERROR, e, this);
return;
}
switch (pak.t) {
case 'READY':
case 'RESUMED':
}
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1333_4,
"
class Test {
#ws;
#serialization;
_packet(raw) {
/** @type {DiscordPacket} */
let pak;
try {
pak = this.#serialization.decode(raw);
} catch (e) {
return;
}
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1333_5,
"
class Test {
#serialization;
_packet(raw) {
pak = this.#serialization.decode(raw);
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1333_6,
"
class Test {
#serialization;
_packet(raw) {
this.#serialization.decode(raw);
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1660_1,
"
console.log(class { run() { } });
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_3055_1,
"
export class Node {
foo() {
this.#bar(this);
}
#bar(parent) {
parent.#baz(this);
parent.baz.#baz(this);
}
#baz(child) { }
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_3618,
"
class MyClass {
get #a() {}
set #a(x) {}
static get #b() {}
static set #b(x) {}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), Mark::new()),
)
},
issue_1694_1,
"
class MyClass {
#get() {
return 1
}
constructor() {
this.#get(foo);
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), Mark::new()),
)
},
issue_1694_2,
"
class MyClass {
static #get() {
return 1
}
constructor() {
MyClass.#get(foo);
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
async_to_generator(Default::default(), Mark::new()),
)
},
issue_1702_1,
"
class Foo {
#y;
static #z = 3;
constructor() {
this.x = 1;
this.#y = 2;
this.#sssss();
}
#sssss() {
console.log(this.x, this.#y, Foo.#z);
}
}
const instance = new Foo();
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1711_1,
"
class Foo {
#value() {
return 1;
}
// #value = 1;
get(target) {
return target.#value;
}
}
"
);
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1742_1,
"
class Foo {
#tag() {
return this;
}
#tag2 = this.#tag;
constructor() {
const receiver = this.#tag`tagged template`;
expect(receiver).toBe(this);
const receiver2 = this.#tag2`tagged template`;
expect(receiver2).toBe(this);
}
}
new Foo();
"
);
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
template_literal(Default::default()),
)
},
issue_1742_2,
"
class Foo {
#tag() {
return this;
}
#tag2 = this.#tag;
constructor() {
const receiver = this.#tag`tagged template`;
expect(receiver).toBe(this);
const receiver2 = this.#tag2`tagged template`;
expect(receiver2).toBe(this);
}
}
new Foo();
"
);
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
new_target_in_class_prop,
"
class Foo {
bar = new.target;
['baz'] = new.target;
}
const foo = new Foo();
expect(foo.bar).toBe(undefined);
expect(foo.baz).toBe(undefined);
"
);
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
class_field_evalutaion_order,
"
class Foo {
a = this.#b;
get #b() {
return 1
}
static #c = this.#d();
static #d() {}
}
expect(() => new Foo()).not.toThrow();
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1742_3,
"
class Foo {
#tag() {
return this;
}
#tag2 = this.#tag;
constructor() {
const receiver = this.#tag`tagged template`;
expect(receiver).toBe(this);
const receiver2 = this.#tag2`tagged template`;
expect(receiver2).toBe(this);
}
}
new Foo();
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1869_1,
"
class TestClass {
static Something = 'hello';
static SomeProperties = {
firstProp: TestClass.Something,
};
}
function someClassDecorator(c) {
return c;
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_1869_2,
"
var _class;
let TestClass = _class = someClassDecorator((_class = class TestClass {
static Something = 'hello';
static SomeProperties = {
firstProp: TestClass.Something
};
}) || _class) || _class;
function someClassDecorator(c) {
return c;
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_2021_1,
"
class Item extends Component {
constructor(props) {
super(props);
}
input = this.props.item;
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_3229_1,
"
class A {
#D;
B() {
1;
C.#D++;
E(function() {});
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_3229_2,
"
class A {
#b;
foo() {
A.#b += 123
class B {
foo() {}
}
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_3368,
"
class A {
#a = 'fff'
static #b = 123
foo() {
return class B {
bar() {
console.log(this.#a, this.#b, this.#bar)
}
}
}
#bar() {}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
nested_class_in_arrow,
"
const a = () => class {
a = 123
foo() {
return class B {
b = 456
}
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_2481,
"
class Foo {
static #prop1 = 42;
static #prop2 = (() => {
console.log(this.#prop1);
})();
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_4473,
"
var test1 = class X {
[Symbol.toStringTag]() {}
}
function a() {
const b = class Y {
x() {
}
}
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
constant_super: true,
..Default::default()
},
unresolved_mark,
),
)
},
constant_super_complex_super,
"
class A extends class B {} {
static x = super.x;
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
constant_super: true,
..Default::default()
},
unresolved_mark,
),
)
},
constant_super_field,
"
class A extends B {
foo = super.bar;
static foo = super.bar;
}
"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
no_document_all: true,
..Default::default()
},
unresolved_mark,
),
)
},
private_optional_chain_member_loose,
r#"
class MyClass {
#a
foo(o) {
o?.#a
}
}
"#
);
test_exec!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
set_public_fields: true,
..Default::default()
},
unresolved_mark,
),
)
},
set_public_fields_initialization_order,
r#"
const actualOrder = [];
const track = i => {
actualOrder.push(i);
return i;
};
class MyClass {
static [track(1)] = track(10);
[track(2)] = track(13);
get [track(3)]() {
return "foo";
}
set [track(4)](value) {
this.bar = value;
}
[track(5)] = track(14);
static [track(6)] = track(11);
static [track(7)] = track(12);
[track(8)]() {}
[track(9)] = track(15);
}
const inst = new MyClass();
const expectedOrder = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
expect(actualOrder).toEqual(expectedOrder);
expect(MyClass[1]).toBe(10);
expect(inst[2]).toBe(13);
expect(inst[3]).toBe("foo");
inst[4] = "baz";
expect(inst.bar).toBe("baz");
expect(inst[5]).toBe(14);
expect(MyClass[6]).toBe(11);
expect(MyClass[7]).toBe(12);
expect(typeof inst[8]).toBe("function");
expect(inst[9]).toBe(15);
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
set_public_fields: true,
..Default::default()
},
unresolved_mark,
),
)
},
set_public_fields_computed,
r#"
const foo = "foo";
const bar = () => {};
const four = 4;
class MyClass {
static [one()] = "test";
static [2 * 4 + 7] = "247";
static [2 * four + 7] = "247";
static [2 * four + seven] = "247";
[null] = "null";
[undefined] = "undefined";
[void 0] = "void 0";
get ["whatever"]() {}
set ["whatever"](value) {}
get [computed()]() {}
set [computed()](value) {}
["test" + one]() {}
static [10]() {}
[/regex/] = "regex";
[foo] = "foo";
[bar] = "bar";
[baz] = "baz";
[`template`] = "template";
[`template${expression}`] = "template-with-expression";
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
set_public_fields: true,
..Default::default()
},
unresolved_mark,
),
)
},
set_public_constructor_collision,
r#"
var foo = "bar";
class Foo {
bar = foo;
static bar = baz;
constructor() {
var foo = "foo";
var baz = "baz";
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
set_public_fields: true,
..Default::default()
},
unresolved_mark,
),
)
},
set_public_static_undefined,
r#"
class Foo {
static bar;
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
private_as_properties: true,
..Default::default()
},
unresolved_mark,
),
)
},
private_as_properties_basic,
r#"
class Cl {
#privateField = "top secret string";
constructor() {
this.publicField = "not secret string";
}
get #privateFieldValue() {
return this.#privateField;
}
set #privateFieldValue(newValue) {
this.#privateField = newValue;
}
publicGetPrivateField() {
return this.#privateFieldValue;
}
publicSetPrivateField(newValue) {
this.#privateFieldValue = newValue;
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
private_as_properties: true,
..Default::default()
},
unresolved_mark,
),
)
},
private_as_properties_static,
r#"
class Cl {
static #foo() {};
static #f = 123;
static get #bar() {};
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
private_as_properties: true,
..Default::default()
},
unresolved_mark,
),
)
},
private_as_properties_getter_only,
r#"
class Cl {
#privateField = 0;
get #privateFieldValue() {
return this.#privateField;
}
constructor() {
this.#privateFieldValue = 1;
([this.#privateFieldValue] = [1]);
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
private_as_properties: true,
set_public_fields: true,
..Default::default()
},
unresolved_mark,
),
)
},
loose_update,
r#"
class Cl {
#privateField = "top secret string";
constructor() {
this.publicField = "not secret string";
}
get #privateFieldValue() {
return this.#privateField;
}
set #privateFieldValue(newValue) {
this.#privateField = newValue;
}
publicGetPrivateField() {
return this.#privateFieldValue;
}
publicSetPrivateField(newValue) {
this.#privateFieldValue = newValue;
}
get publicFieldValue() {
return this.publicField;
}
set publicFieldValue(newValue) {
this.publicField = newValue;
}
testUpdates() {
this.#privateField = 0;
this.publicField = 0;
this.#privateFieldValue = this.#privateFieldValue++;
this.publicFieldValue = this.publicFieldValue++;
++this.#privateFieldValue;
++this.publicFieldValue;
this.#privateFieldValue += 1;
this.publicFieldValue += 1;
this.#privateFieldValue = -(this.#privateFieldValue ** this.#privateFieldValue);
this.publicFieldValue = -(this.publicFieldValue ** this.publicFieldValue);
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
set_only_getter,
r#"
class Cl {
#privateField = 0;
counter = 0;
get #privateFieldValue() {
return this.#privateField;
}
get self() {
this.counter++;
return this;
}
constructor() {
this.self.#privateFieldValue = 1;
([this.self.#privateFieldValue] = [1]);
}
}
const cl = new Cl();
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
get_only_setter,
r#"
class Cl {
#privateField = 0;
set #privateFieldValue(newValue) {
this.#privateField = newValue;
}
constructor() {
this.publicField = this.#privateFieldValue;
}
}
"#
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(
class_properties::Config {
private_as_properties: true,
..Default::default()
},
unresolved_mark,
),
)
},
loose_keyword_method,
r##"
class TestCls{
foo(){
this.#bar()
this.#switch()
}
#switch(){
console.log("#switch called")
}
#bar(){
console.log("#bar called")
}
}
export {TestCls}
let a = new TestCls
a.foo()
"##
);
#[testing::fixture("tests/classes/**/exec.js")]
fn exec(input: PathBuf) {
let src = read_to_string(input).unwrap();
compare_stdout(
Default::default(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
)
},
&src,
);
}
#[testing::fixture("tests/class-properties/**/input.js")]
fn fixture(input: PathBuf) {
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
)
},
&input,
&input.with_file_name("output.js"),
Default::default(),
);
}
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, true),
class_properties(Default::default(), unresolved_mark),
)
},
issue_6305,
"class x { static #x = super.x = 0 }"
);
test!(
syntax(),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
class_properties(Default::default(), unresolved_mark),
optional_chaining(Default::default(), unresolved_mark),
)
},
issue_8003,
"
class Foo {
#priv
search() {
this.#priv?.()
}
}
console.log(new Foo().search())"
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2022_private_in_object.rs | Rust | use std::path::PathBuf;
use serde::Deserialize;
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::{
es2015::classes,
es2022::{class_properties, private_in_object},
};
use swc_ecma_transforms_testing::{parse_options, test_fixture};
#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
struct TestOptions {
plugins: Vec<PluginConfig>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(untagged)]
enum PluginConfig {
WithOption(String, #[serde(default)] serde_json::Value),
Name(String),
}
#[testing::fixture("tests/private-in-object/**/input.js")]
fn fixture(input: PathBuf) {
let parent = input.parent().unwrap();
let options: TestOptions = parse_options(parent);
let output = parent.join("output.js");
test_fixture(
Default::default(),
&|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
let mut pass: Box<dyn Pass> =
Box::new(resolver(unresolved_mark, top_level_mark, false));
let mut class_props = false;
for plugin in &options.plugins {
let (name, _option) = match plugin {
PluginConfig::WithOption(name, config) => (name, config.clone()),
PluginConfig::Name(name) => (name, serde_json::Value::Null),
};
let loose = input.to_string_lossy().contains("private-loose");
match &**name {
"proposal-private-property-in-object" => {}
"proposal-class-properties" => {
if !class_props {
class_props = true;
pass = Box::new((
pass,
class_properties(
class_properties::Config {
set_public_fields: loose,
constant_super: loose,
no_document_all: loose,
private_as_properties: loose,
pure_getter: loose,
},
unresolved_mark,
),
));
}
}
"proposal-private-methods" => {
if !class_props {
class_props = true;
pass = Box::new((
pass,
class_properties(
class_properties::Config {
set_public_fields: loose,
constant_super: loose,
no_document_all: loose,
private_as_properties: loose,
pure_getter: loose,
},
unresolved_mark,
),
));
}
}
"transform-classes" => {
pass = Box::new((pass, classes(Default::default())));
}
_ => {
panic!("unknown pass: {}", name)
}
}
}
pass = Box::new((pass, private_in_object()));
pass
},
&input,
&output,
Default::default(),
)
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/es2022_static_blocks.rs | Rust | use std::path::PathBuf;
use swc_common::Mark;
use swc_ecma_ast::Pass;
use swc_ecma_parser::Syntax;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::es2022::{class_properties, static_blocks};
use swc_ecma_transforms_testing::test_fixture;
#[testing::fixture("tests/static-blocks/**/input.js")]
fn fixture(input: PathBuf) {
let parent = input.parent().unwrap();
let output = parent.join("output.js");
test_fixture(
Syntax::Es(Default::default()),
&|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
let config = class_properties::Config::default();
let pass: Box<dyn Pass> = if input.to_string_lossy().contains("class-properties") {
Box::new((
resolver(unresolved_mark, top_level_mark, false),
static_blocks(),
class_properties(config, unresolved_mark),
))
} else {
Box::new((
resolver(unresolved_mark, top_level_mark, false),
static_blocks(),
))
};
pass
},
&input,
&output,
Default::default(),
)
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/1/exec.js | JavaScript | for (const a of [1, 2, 3]) {
for (const b of [4, 5, 6]) {
console.log(a, b);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/issue-2622/1/exec.js | JavaScript | for (let a = 0; a < 2; a++) {
for (let b = 0; b < 2; b++) {
() => {};
for (let c = 0; c < 2; c++) {
console.log(b);
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/issue-2799/1/exec.js | JavaScript | const block = () => {
for (const value in { a: 1, b: 2, c: 3 }) {
for (let i = 0; i < 10; i++) {
function something() {}
continue;
return { value };
}
}
};
console.log(block());
console.log("OK?");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/issue-2915/1/exec.js | JavaScript | function foo(baz) {
for (const g in baz) {
console.log(g);
for (let j = 0; j < g.length; j++) {
console.log(j);
}
}
}
console.log(
foo({
a: [1],
b: [2, 2],
c: [3, 3, 3],
})
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/issue-3006/1/exec.js | JavaScript | for (const number_in_a_sequence of Array.from(new Array(7), (_, i) => i)) {
setTimeout(() => console.log(number_in_a_sequence), 10);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/issue-8010/1/exec.js | JavaScript | for (const x of [0, 1, 2]) {
for (let i = 0; i < 1; i++) {
setTimeout(() => console.log(x));
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/next-31757/1/exec.js | JavaScript | let message = 0;
for (let x of [1, 2, 3, 4, 5]) {
for (let y of ["a", "b", "c", "d"]) {
console.log("Message", ++message, x, y);
[].forEach(() => {});
break;
}
}
console.log("WHY", message == 5);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/next-31757/2/exec.js | JavaScript | let message = 0;
for (let x of [1, 2, 3, 4, 5]) {
for (let y of ["a", "b", "c", "d"]) {
console.log("Message", ++message, x, y);
break;
}
}
console.log("WHY", message == 5);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_compat/tests/for-of/spec-identifier/input.js | JavaScript | for (i of arr) {
} | 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.