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_proposal/tests/explicit-resource-management/exec-async/using-undefined-multiple.js | JavaScript | return (async function () {
const log = [];
function disposable(name) {
return {
async [Symbol.dispose || Symbol.for("Symbol.dispose")]() {
log.push(name);
},
};
}
async function f() {
using y = disposable("y");
await using x = undefined;
log.push("f body");
}
const promise = f();
log.push("body");
await promise;
expect(log).toEqual(["f body", "body", "y"]);
})();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/completion-break.js | JavaScript | let disposed = false;
let beforeBreak;
while (true) {
using x = {
[Symbol.dispose || Symbol.for("Symbol.dispose")]() {
disposed = true;
}
};
beforeBreak = disposed;
break;
}
expect(beforeBreak).toBe(false);
expect(disposed).toBe(true);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/completion-normal.js | JavaScript | let disposed = false;
let beforeEnd;
{
using x = {
[Symbol.dispose || Symbol.for("Symbol.dispose")]() {
disposed = true;
}
};
beforeEnd = disposed;
}
expect(beforeEnd).toBe(false);
expect(disposed).toBe(true);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/completion-return.js | JavaScript | let disposed = false;
let beforeReturn;
(function () {
using x = {
[Symbol.dispose || Symbol.for("Symbol.dispose")]() {
disposed = true;
}
};
beforeReturn = disposed;
return 0;
})();
expect(beforeReturn).toBe(false);
expect(disposed).toBe(true);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/completion-throw.js | JavaScript | let disposed = false;
let beforeReturn;
let inCatch;
let inFinally;
try {
using x = {
[Symbol.dispose || Symbol.for("Symbol.dispose")]() {
disposed = true;
throw 1;
},
};
beforeReturn = disposed;
throw 0;
} catch (e) {
inCatch = disposed;
expect(e.name).toBe("SuppressedError");
expect(e.suppressed).toBe(0);
expect(e.error).toBe(1);
}
expect(beforeReturn).toBe(false);
expect(inCatch).toBe(true);
expect(disposed).toBe(true);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/invalid-dispose-not-a-function.js | JavaScript | expect(() => {
using foo = { [Symbol.dispose || Symbol.for("Symbol.dispose")]: 3 };
}).toThrow(TypeError);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/invalid-not-object.js | JavaScript | expect(() => {
using x = 2;
}).toThrow(TypeError);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/multiple.js | JavaScript | let log = [];
function disposable(name){
return {
[Symbol.dispose || Symbol.for("Symbol.dispose")]() {
log.push(name);
}
};
}
{
using x = disposable("x");
using y = disposable("y"), z = disposable("z");
using w = disposable("w");
log.push("body");
}
expect(log).toEqual(["body", "w", "z", "y", "x"]);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/using-function.js | JavaScript | let log = [];
function disposable() { log.push('call') }
disposable[Symbol.dispose || Symbol.for("Symbol.dispose")] = () => { log.push('dispose') };
{
using x = disposable;
x();
}
expect(log).toEqual(['call', 'dispose']);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/exec-sync/using-null.js | JavaScript | expect(() => {
using x = null;
using y = undefined;
}).not.toThrow();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/integration/async-to-generator/input.js | JavaScript | async function fn() {
await 0;
{
await using x = y;
await 1;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/integration/async-to-generator/output.js | JavaScript | async function fn() {
await 0;
{
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, y, true);
await 1;
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
const result = _ts_dispose_resources(env);
if (result) await result;
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/source-maps/block/input.js | JavaScript | {
using x = fn();
doSomethingWith(x);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/source-maps/block/output.js | JavaScript | {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, fn(), false);
doSomethingWith(x);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/source-maps/for-of/input.js | JavaScript | for (using x of it) {
doSomethingWith(x);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/source-maps/for-of/output.js | JavaScript | for (const _ of it){
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, _, false);
{
doSomethingWith(x);
}
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/source-maps/switch/input.js | JavaScript | function f() {
switch (v) {
case 0:
using x = 0;
break;
default:
using y = 1;
break;
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/source-maps/switch/output.js | JavaScript | function f() {
switch(v){
case 0:
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, 0, false);
break;
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
default:
const env1 = {
stack: [],
error: void 0,
hasError: false
};
try {
const y = _ts_add_disposable_resource(env1, 1, false);
break;
} catch (e) {
env1.error = e;
env1.hasError = true;
} finally{
_ts_dispose_resources(env1);
}
}
;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/source-maps/top-level/input.mjs | JavaScript | before;
using x = fn();
doSomethingWith(x);
after;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/source-maps/top-level/output.mjs | JavaScript | const env = {
stack: [],
error: void 0,
hasError: false
};
try {
before;
const x = _ts_add_disposable_resource(env, fn(), false);
doSomethingWith(x);
after;
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/mixed/input.js | JavaScript | {
using a = 1;
await using b = 2;
using c = 3;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/mixed/output.js | JavaScript | {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const a = _ts_add_disposable_resource(env, 1, false);
const b = _ts_add_disposable_resource(env, 2, true);
const c = _ts_add_disposable_resource(env, 3, false);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
const result = _ts_dispose_resources(env);
if (result) await result;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/mixed/output.mjs | JavaScript | try {
var _usingCtx = babelHelpers.usingCtx();
const a = _usingCtx.u(1);
const b = _usingCtx.a(2);
const c = _usingCtx.u(3);
} catch (_) {
_usingCtx.e = _;
} finally {
await _usingCtx.d();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/only-using-await/input.js | JavaScript | {
await using x = obj;
stmt;
await using y = obj, z = obj;
doSomethingWith(x, y);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/only-using-await/output.js | JavaScript | {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, obj, true);
stmt;
const y = _ts_add_disposable_resource(env, obj, true), z = _ts_add_disposable_resource(env, obj, true);
doSomethingWith(x, y);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
const result = _ts_dispose_resources(env);
if (result) await result;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/only-using-await/output.mjs | JavaScript | try {
var _usingCtx = babelHelpers.usingCtx();
const x = _usingCtx.a(obj);
stmt;
const y = _usingCtx.a(obj),
z = _usingCtx.a(obj);
doSomethingWith(x, y);
} catch (_) {
_usingCtx.e = _;
} finally {
await _usingCtx.d();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/switch/input.js | JavaScript | async function f() {
switch (v) {
case 0:
await using x = 0;
break;
default:
await using y = 1;
break;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/switch/output.js | JavaScript | async function f() {
switch(v){
case 0:
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, 0, true);
break;
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
const result = _ts_dispose_resources(env);
if (result) await result;
}
default:
const env1 = {
stack: [],
error: void 0,
hasError: false
};
try {
const y = _ts_add_disposable_resource(env1, 1, true);
break;
} catch (e) {
env1.error = e;
env1.hasError = true;
} finally{
const result = _ts_dispose_resources(env1);
if (result) await result;
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-await/switch/output.mjs | JavaScript | async function f() {
try {
var _usingCtx = babelHelpers.usingCtx();
switch (v) {
case 0:
const x = _usingCtx.a(0);
break;
default:
const y = _usingCtx.a(1);
break;
}
} catch (_) {
_usingCtx.e = _;
} finally {
await _usingCtx.d();
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/bare-block/input.js | JavaScript | {
using x = obj;
doSomethingWith(x);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/bare-block/output.js | JavaScript | {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, obj, false);
doSomethingWith(x);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/for-await-head/input.js | JavaScript | for await (using x of y) {
doSomethingWith(x);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/for-await-head/output.js | JavaScript | for await (const _ of y){
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, _, false);
{
doSomethingWith(x);
}
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/for-await-head/output.mjs | JavaScript | for await (const _x of y) try {
var _usingCtx = babelHelpers.usingCtx();
const x = _usingCtx.u(_x);
doSomethingWith(x);
} catch (_) {
_usingCtx.e = _;
} finally {
_usingCtx.d();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/for-head/input.js | JavaScript | for (using x of y) {
doSomethingWith(x);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/for-head/output.js | JavaScript | for (const _ of y){
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, _, false);
{
doSomethingWith(x);
}
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/function-body/input.js | JavaScript | function fn() {
using x = obj;
return doSomethingWith(x);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/function-body/output.js | JavaScript | function fn() {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, obj, false);
return doSomethingWith(x);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/if-body/input.js | JavaScript | if (test) {
using x = obj;
doSomethingWith(x);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/if-body/output.js | JavaScript | if (test) {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, obj, false);
doSomethingWith(x);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/multiple-nested/input.js | JavaScript | {
using x = obj;
{
using y = call(() => {
using z = obj;
return z;
});
stmt;
}
stmt;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/multiple-nested/output.js | JavaScript | {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, obj, false);
{
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const y = _ts_add_disposable_resource(env, call(()=>{
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const z = _ts_add_disposable_resource(env, obj, false);
return z;
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}), false);
stmt;
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
stmt;
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/multiple-same-level/input.js | JavaScript | {
stmt;
using x = obj;
stmt;
using y = obj, z = obj;
stmt;
using w = obj;
doSomethingWith(x, z);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/multiple-same-level/output.js | JavaScript | {
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
stmt;
const x = _ts_add_disposable_resource(env, obj, false);
stmt;
const y = _ts_add_disposable_resource(env, obj, false), z = _ts_add_disposable_resource(env, obj, false);
stmt;
const w = _ts_add_disposable_resource(env, obj, false);
doSomethingWith(x, z);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/static-block/input.js | JavaScript | class A {
static {
using x = y;
doSomethingWith(x);
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/static-block/output.js | JavaScript | class A {
static{
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, y, false);
doSomethingWith(x);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/switch/input.js | JavaScript | function f() {
switch (v) {
case 0:
using x = 0;
break;
default:
using y = 1;
break;
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-sync/switch/output.js | JavaScript | function f() {
switch(v){
case 0:
const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, 0, false);
break;
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
default:
const env1 = {
stack: [],
error: void 0,
hasError: false
};
try {
const y = _ts_add_disposable_resource(env1, 1, false);
break;
} catch (e) {
env1.error = e;
env1.hasError = true;
} finally{
_ts_dispose_resources(env1);
}
}
;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/await-or-not-preserved/input.mjs | JavaScript | using x = A;
await using y = B;
export { x, y };
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/await-or-not-preserved/output.mjs | JavaScript | const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, A, false);
const y = _ts_add_disposable_resource(env, B, true);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
const result = _ts_dispose_resources(env);
if (result) await result;
}
export { x, y };
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-clas-anon/input.mjs | JavaScript | using x = null;
export default class {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-clas-anon/output.mjs | JavaScript | const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, null, false);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
export default class {
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-class/input.mjs | JavaScript | using x = null;
export default class C {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-class/output.mjs | JavaScript | const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, null, false);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
export default class C {
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-expr/input.mjs | JavaScript | using x = null;
export default doSomething();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-expr/output.mjs | JavaScript | const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, null, false);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
export default doSomething();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-fn-anon/input.mjs | JavaScript | using x = null;
export default function fn() {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-fn-anon/output.mjs | JavaScript | const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, null, false);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
export default function fn() {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-fn/input.mjs | JavaScript | using x = null;
export default function fn() {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting-default-fn/output.mjs | JavaScript | const env = {
stack: [],
error: void 0,
hasError: false
};
try {
const x = _ts_add_disposable_resource(env, null, false);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
export default function fn() {}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting/input.mjs | JavaScript | import { doSomething } from "somewhere";
export * from "somewhere else";
export * as ns from "somewhere else";
function f() { a; B; }
function h() { b; A; }
export function g() { c; }
doSomething();
export { f };
export let { b } = {};
let c = 2;
class A {}
export class B {}
using x = null;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit-resource-management/transform-top-level/hoisting/output.mjs | JavaScript | const env = {
stack: [],
error: void 0,
hasError: false
};
try {
function f() {
a;
B;
}
function h() {
b;
A;
}
doSomething();
let c = 2;
class A {
}
const x = _ts_add_disposable_resource(env, null, false);
} catch (e) {
env.error = e;
env.hasError = true;
} finally{
_ts_dispose_resources(env);
}
import { doSomething } from "somewhere";
export * from "somewhere else";
export * as ns from "somewhere else";
export function g() {
c;
}
export { f };
export let { b } = {};
export class B {
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/explicit_resource_management.rs | Rust | use std::{fs::read_to_string, path::PathBuf};
use swc_common::Mark;
use swc_ecma_parser::{EsSyntax, Syntax};
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_proposal::explicit_resource_management::explicit_resource_management;
use swc_ecma_transforms_testing::{exec_tr, test_fixture, FixtureTestConfig};
#[testing::fixture("tests/explicit-resource-management/exec-sync/**/*.js")]
#[testing::fixture("tests/explicit-resource-management/exec-async/**/*.js")]
fn exec(input: PathBuf) {
exec_tr(
"explicit-resource-management",
Syntax::Es(EsSyntax {
explicit_resource_management: true,
..Default::default()
}),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
explicit_resource_management(),
)
},
&read_to_string(input).unwrap(),
);
}
#[testing::fixture("tests/explicit-resource-management/**/input.js")]
#[testing::fixture("tests/explicit-resource-management/**/input.mjs")]
fn fixture(input: PathBuf) {
run_fixture(input);
}
fn run_fixture(input: PathBuf) {
let output = input.with_file_name(format!(
"output.{}",
input.extension().unwrap().to_string_lossy()
));
test_fixture(
Syntax::Es(EsSyntax {
explicit_resource_management: true,
..Default::default()
}),
&|_t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
explicit_resource_management(),
)
},
&input,
&output,
FixtureTestConfig {
..Default::default()
},
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/export.rs | Rust | use swc_ecma_ast::Pass;
use swc_ecma_parser::{EsSyntax, Syntax};
use swc_ecma_transforms_compat::es2020::export_namespace_from;
use swc_ecma_transforms_proposal::export_default_from;
use swc_ecma_transforms_testing::test;
fn syntax_default() -> Syntax {
Syntax::Es(EsSyntax {
export_default_from: true,
..Default::default()
})
}
fn syntax_namespace() -> Syntax {
Syntax::Es(Default::default())
}
fn tr() -> impl Pass {
(export_default_from(), export_namespace_from())
}
test!(
syntax_default(),
|_| tr(),
default_es6,
r#"export foo from "bar";"#
);
test!(
syntax_default(),
|_| tr(),
default_compounded_es6,
r#"export v, { x, y as w } from "mod";"#
);
test!(
syntax_default(),
|_| tr(),
namespace_compound_es6,
r"export * as foo, { bar } from 'bar';"
);
test!(
syntax_namespace(),
|_| tr(),
namespace_default,
"export * as default from 'foo';"
);
test!(
syntax_namespace(),
|_| tr(),
namespace_es6,
"export * as foo from 'bar';"
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_proposal/tests/import_assertions.rs | Rust | use swc_ecma_ast::Pass;
use swc_ecma_parser::{EsSyntax, Syntax};
use swc_ecma_transforms_proposal::import_attributes;
use swc_ecma_transforms_testing::test;
fn tr() -> impl Pass {
import_attributes()
}
fn syntax() -> Syntax {
Syntax::Es(EsSyntax {
import_attributes: true,
..Default::default()
})
}
test!(
syntax(),
|_| tr(),
import_with_assertions,
r#"import test from "./test.json" assert {type: "json"};"#
);
test!(
syntax(),
|_| tr(),
side_effect_import_with_assertions,
r#"import "./test.json" assert {type: "json"};"#
);
test!(
syntax(),
|_| tr(),
named_export_with_assertions,
r#"export {default as test} from "./test.json" assert {type: "json"};"#
);
test!(
syntax(),
|_| tr(),
export_all_with_assertions,
r#"export * from "./test.json" assert {type: "json"};"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/scripts/patch-options.sh | Shell | #!/usr/bin/env bash
npx tsc scripts/patch-options.ts
node scripts/patch-options.js | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/scripts/patch-options.ts | TypeScript | import * as fs from "fs";
import * as path from "path";
async function* walk(dir: string): AsyncGenerator<string> {
for await (const d of await fs.promises.opendir(dir)) {
const entry = path.join(dir, d.name);
if (d.isDirectory()) yield* walk(entry);
else if (d.isFile()) yield entry;
}
}
// Then, use it with a simple async for loop
async function main() {
// TODO: Generalize path
for await (const f of walk("src/jsx/fixture")) {
if (!f.endsWith(".json")) {
continue;
}
const obj = JSON.parse(
await fs.promises.readFile(f, { encoding: "utf-8" })
);
const dir = path.dirname(f);
if (obj.throws) {
await fs.promises.writeFile(
path.join(dir, "output.stderr"),
obj.throws
);
}
console.log(f);
if (obj.plugins) {
if (obj.plugins.includes("transform-react-jsx")) {
const newObj = {
...obj,
};
delete newObj.sourceType;
delete newObj.plugins;
await fs.promises.writeFile(f, JSON.stringify(newObj), {
encoding: "utf-8",
});
continue;
}
for (const [plugin, config] of obj.plugins) {
if (plugin === "transform-react-jsx") {
console.log(plugin, config);
const newObj = {
...obj,
...config,
};
delete newObj.sourceType;
delete newObj.plugins;
await fs.promises.writeFile(f, JSON.stringify(newObj), {
encoding: "utf-8",
});
break;
}
}
}
}
}
main();
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/display_name/mod.rs | Rust | use std::ops::DerefMut;
use swc_common::DUMMY_SP;
use swc_ecma_ast::*;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
#[cfg(test)]
mod tests;
/// `@babel/plugin-transform-react-display-name`
///
/// Add displayName to React.createClass calls
pub fn display_name() -> impl Pass {
visit_mut_pass(DisplayName)
}
struct DisplayName;
impl VisitMut for DisplayName {
noop_visit_mut_type!();
fn visit_mut_assign_expr(&mut self, expr: &mut AssignExpr) {
expr.visit_mut_children_with(self);
if expr.op != op!("=") {
return;
}
if let AssignTarget::Simple(
SimpleAssignTarget::Member(MemberExpr {
prop: MemberProp::Ident(prop),
..
})
| SimpleAssignTarget::SuperProp(SuperPropExpr {
prop: SuperProp::Ident(prop),
..
}),
) = &expr.left
{
return expr.right.visit_mut_with(&mut Folder {
name: Some(
Lit::Str(Str {
span: prop.span,
raw: None,
value: prop.sym.clone(),
})
.into(),
),
});
};
if let Some(ident) = expr.left.as_ident() {
expr.right.visit_mut_with(&mut Folder {
name: Some(
Lit::Str(Str {
span: ident.span,
raw: None,
value: ident.sym.clone(),
})
.into(),
),
});
}
}
fn visit_mut_module_decl(&mut self, decl: &mut ModuleDecl) {
decl.visit_mut_children_with(self);
if let ModuleDecl::ExportDefaultExpr(e) = decl {
e.visit_mut_with(&mut Folder {
name: Some(
Lit::Str(Str {
span: DUMMY_SP,
raw: None,
value: "input".into(),
})
.into(),
),
});
}
}
fn visit_mut_prop(&mut self, prop: &mut Prop) {
prop.visit_mut_children_with(self);
if let Prop::KeyValue(KeyValueProp { key, value }) = prop {
value.visit_mut_with(&mut Folder {
name: Some(match key {
PropName::Ident(ref i) => Lit::Str(Str {
span: i.span,
raw: None,
value: i.sym.clone(),
})
.into(),
PropName::Str(ref s) => Lit::Str(s.clone()).into(),
PropName::Num(ref n) => Lit::Num(n.clone()).into(),
PropName::BigInt(ref b) => Lit::BigInt(b.clone()).into(),
PropName::Computed(ref c) => c.expr.clone(),
}),
});
}
}
fn visit_mut_var_declarator(&mut self, decl: &mut VarDeclarator) {
if let Pat::Ident(ref ident) = decl.name {
decl.init.visit_mut_with(&mut Folder {
name: Some(
Lit::Str(Str {
span: ident.span,
value: ident.sym.clone(),
raw: None,
})
.into(),
),
});
}
}
}
struct Folder {
name: Option<Box<Expr>>,
}
impl VisitMut for Folder {
noop_visit_mut_type!();
/// Don't recurse into array.
fn visit_mut_array_lit(&mut self, _: &mut ArrayLit) {}
fn visit_mut_call_expr(&mut self, expr: &mut CallExpr) {
expr.visit_mut_children_with(self);
if is_create_class_call(expr) {
let name = match self.name.take() {
Some(name) => name,
None => return,
};
add_display_name(expr, name)
}
}
/// Don't recurse into object.
fn visit_mut_object_lit(&mut self, _: &mut ObjectLit) {}
}
fn is_create_class_call(call: &CallExpr) -> bool {
let callee = match &call.callee {
Callee::Super(_) | Callee::Import(_) => return false,
Callee::Expr(callee) => &**callee,
};
match callee {
Expr::Member(MemberExpr { obj, prop, .. }) if prop.is_ident_with("createClass") => {
if obj.is_ident_ref_to("React") {
return true;
}
}
Expr::Ident(Ident { sym, .. }) if &**sym == "createReactClass" => return true,
_ => {}
}
false
}
fn add_display_name(call: &mut CallExpr, name: Box<Expr>) {
let props = match call.args.first_mut() {
Some(&mut ExprOrSpread { ref mut expr, .. }) => match expr.deref_mut() {
Expr::Object(ObjectLit { ref mut props, .. }) => props,
_ => return,
},
_ => return,
};
for prop in &*props {
if is_key_display_name(prop) {
return;
}
}
props.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident("displayName".into()),
value: name,
}))));
}
fn is_key_display_name(prop: &PropOrSpread) -> bool {
match *prop {
PropOrSpread::Prop(ref prop) => match **prop {
Prop::Shorthand(ref i) => i.sym == "displayName",
Prop::Method(MethodProp { ref key, .. })
| Prop::Getter(GetterProp { ref key, .. })
| Prop::Setter(SetterProp { ref key, .. })
| Prop::KeyValue(KeyValueProp { ref key, .. }) => match *key {
PropName::Ident(ref i) => i.sym == "displayName",
PropName::Str(ref s) => s.value == "displayName",
PropName::Num(..) => false,
PropName::BigInt(..) => false,
PropName::Computed(..) => false,
},
Prop::Assign(..) => unreachable!("invalid syntax"),
},
_ => false,
// TODO(kdy1): maybe.. handle spread
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/display_name/tests.rs | Rust | use swc_ecma_transforms_testing::test;
use super::*;
fn tr() -> impl Pass {
display_name()
}
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
assignment_expression,
r#"
foo = createReactClass({});
bar = React.createClass({});
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
nested,
r#"
var foo = qux(createReactClass({}));
var bar = qux(React.createClass({}));
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
object_property,
r#"
({
foo: createReactClass({})
});
({
bar: React.createClass({})
});
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
variable_declarator,
r#"
var foo = createReactClass({});
var bar = React.createClass({});
"#
);
test!(
::swc_ecma_parser::Syntax::default(),
|_| tr(),
assignment_expression_with_member,
r#"
foo.x = createReactClass({});
class A extends B { render() { super.x = React.createClass({}) } };
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/jsx/mod.rs | Rust | #![allow(clippy::redundant_allocation)]
use std::{
borrow::Cow,
iter::{self, once},
sync::RwLock,
};
use once_cell::sync::Lazy;
use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize};
use string_enum::StringEnum;
use swc_atoms::{atom, Atom};
use swc_common::{
comments::{Comment, CommentKind, Comments},
errors::HANDLER,
iter::IdentifyLast,
sync::Lrc,
util::take::Take,
FileName, Mark, SourceMap, Span, Spanned, SyntaxContext, DUMMY_SP,
};
use swc_config::merge::Merge;
use swc_ecma_ast::*;
use swc_ecma_parser::{parse_file_as_expr, Syntax};
use swc_ecma_utils::{drop_span, prepend_stmt, private_ident, quote_ident, ExprFactory, StmtLike};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
use self::static_check::should_use_create_element;
use crate::refresh::options::{deserialize_refresh, RefreshOptions};
mod static_check;
#[cfg(test)]
mod tests;
/// https://babeljs.io/docs/en/babel-plugin-transform-react-jsx#runtime
#[derive(StringEnum, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Hash)]
pub enum Runtime {
/// `automatic`
Automatic,
/// `classic`
Classic,
}
/// Note: This will changed in v2
impl Default for Runtime {
fn default() -> Self {
Runtime::Classic
}
}
#[derive(Debug, Default, Clone, Serialize, Deserialize, Eq, PartialEq, Merge)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
pub struct Options {
/// If this is `true`, swc will behave just like babel 8 with
/// `BABEL_8_BREAKING: true`.
#[serde(skip, default)]
pub next: Option<bool>,
#[serde(default)]
pub runtime: Option<Runtime>,
/// For automatic runtime
#[serde(default)]
pub import_source: Option<Atom>,
#[serde(default)]
pub pragma: Option<Lrc<String>>,
#[serde(default)]
pub pragma_frag: Option<Lrc<String>>,
#[serde(default)]
pub throw_if_namespace: Option<bool>,
#[serde(default)]
pub development: Option<bool>,
// @babel/plugin-transform-react-jsx: Since "useBuiltIns" is removed in Babel 8, you can remove
// it from the config.
#[deprecated(
since = "0.167.4",
note = r#"Since `useBuiltIns` is removed in swc, you can remove it from the config."#
)]
#[serde(default, alias = "useBuiltIns")]
pub use_builtins: Option<bool>,
// '@babel/plugin-transform-react-jsx: Since Babel 8, an inline object with spread elements is
// always used, and the "useSpread" option is no longer available. Please remove it from your
// config.',
#[deprecated(
since = "0.167.4",
note = r#"An inline object with spread elements is always used, and the `useSpread` option is no longer available. Please remove it from your config."#
)]
#[serde(default)]
pub use_spread: Option<bool>,
#[serde(default, deserialize_with = "deserialize_refresh")]
// default to disabled since this is still considered as experimental by now
pub refresh: Option<RefreshOptions>,
}
#[cfg(feature = "concurrent")]
macro_rules! static_str {
($s:expr) => {{
static VAL: Lazy<Lrc<String>> = Lazy::new(|| Lrc::new($s.into()));
VAL.clone()
}};
}
#[cfg(not(feature = "concurrent"))]
macro_rules! static_str {
($s:expr) => {
Lrc::new($s.into())
};
}
pub fn default_import_source() -> Atom {
atom!("react")
}
pub fn default_pragma() -> Lrc<String> {
static_str!("React.createElement")
}
pub fn default_pragma_frag() -> Lrc<String> {
static_str!("React.Fragment")
}
fn default_throw_if_namespace() -> bool {
true
}
/// Parse `src` to use as a `pragma` or `pragmaFrag` in jsx.
pub fn parse_expr_for_jsx(
cm: &SourceMap,
name: &str,
src: Lrc<String>,
top_level_mark: Mark,
) -> Box<Expr> {
let fm = cm.new_source_file_from(
FileName::Internal(format!("jsx-config-{}.js", name)).into(),
src,
);
parse_file_as_expr(
&fm,
Syntax::default(),
Default::default(),
None,
&mut Vec::new(),
)
.map_err(|e| {
if HANDLER.is_set() {
HANDLER.with(|h| {
e.into_diagnostic(h)
.note("Failed to parse jsx pragma")
.emit()
})
}
})
.map(drop_span)
.map(|mut expr| {
apply_mark(&mut expr, top_level_mark);
expr
})
.unwrap_or_else(|()| {
panic!(
"failed to parse jsx option {}: '{}' is not an expression",
name, fm.src,
)
})
}
fn apply_mark(e: &mut Expr, mark: Mark) {
match e {
Expr::Ident(i) => {
i.ctxt = i.ctxt.apply_mark(mark);
}
Expr::Member(MemberExpr { obj, .. }) => {
apply_mark(obj, mark);
}
_ => {}
}
}
/// `@babel/plugin-transform-react-jsx`
///
/// Turn JSX into React function calls
///
///
/// `top_level_mark` should be [Mark] passed to
/// [swc_ecma_transforms_base::resolver::resolver_with_mark].
///
///
/// # Parameters
///
/// ## `top_level_ctxt`
///
/// This is used to reference `React` defined by the user.
///
/// e.g.
///
/// ```js
/// import React from 'react';
/// ```
pub fn jsx<C>(
cm: Lrc<SourceMap>,
comments: Option<C>,
options: Options,
top_level_mark: Mark,
unresolved_mark: Mark,
) -> impl Pass + VisitMut
where
C: Comments,
{
visit_mut_pass(Jsx {
cm: cm.clone(),
top_level_mark,
unresolved_mark,
runtime: options.runtime.unwrap_or_default(),
import_source: options.import_source.unwrap_or_else(default_import_source),
import_jsx: None,
import_jsxs: None,
import_fragment: None,
import_create_element: None,
pragma: Lrc::new(parse_expr_for_jsx(
&cm,
"pragma",
options.pragma.unwrap_or_else(default_pragma),
top_level_mark,
)),
comments,
pragma_frag: Lrc::new(parse_expr_for_jsx(
&cm,
"pragmaFrag",
options.pragma_frag.unwrap_or_else(default_pragma_frag),
top_level_mark,
)),
development: options.development.unwrap_or_default(),
throw_if_namespace: options
.throw_if_namespace
.unwrap_or_else(default_throw_if_namespace),
top_level_node: true,
})
}
struct Jsx<C>
where
C: Comments,
{
cm: Lrc<SourceMap>,
top_level_mark: Mark,
unresolved_mark: Mark,
runtime: Runtime,
/// For automatic runtime.
import_source: Atom,
/// For automatic runtime.
import_jsx: Option<Ident>,
/// For automatic runtime.
import_jsxs: Option<Ident>,
/// For automatic runtime.
import_create_element: Option<Ident>,
/// For automatic runtime.
import_fragment: Option<Ident>,
top_level_node: bool,
pragma: Lrc<Box<Expr>>,
comments: Option<C>,
pragma_frag: Lrc<Box<Expr>>,
development: bool,
throw_if_namespace: bool,
}
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct JsxDirectives {
pub runtime: Option<Runtime>,
/// For automatic runtime.
pub import_source: Option<Atom>,
/// Parsed from `@jsx`
pub pragma: Option<Lrc<Box<Expr>>>,
/// Parsed from `@jsxFrag`
pub pragma_frag: Option<Lrc<Box<Expr>>>,
}
fn respan(e: &mut Expr, span: Span) {
match e {
Expr::Ident(i) => {
i.span.lo = span.lo;
i.span.hi = span.hi;
}
Expr::Member(e) => {
e.span = span;
}
_ => {}
}
}
impl JsxDirectives {
pub fn from_comments(
cm: &SourceMap,
_: Span,
comments: &[Comment],
top_level_mark: Mark,
) -> Self {
let mut res = JsxDirectives::default();
for cmt in comments {
if cmt.kind != CommentKind::Block {
continue;
}
for line in cmt.text.lines() {
let mut line = line.trim();
if line.starts_with('*') {
line = line[1..].trim();
}
if !line.starts_with("@jsx") {
continue;
}
let mut words = line.split_whitespace();
loop {
let pragma = words.next();
if pragma.is_none() {
break;
}
let val = words.next();
match pragma {
Some("@jsxRuntime") => match val {
Some("classic") => res.runtime = Some(Runtime::Classic),
Some("automatic") => res.runtime = Some(Runtime::Automatic),
None => {}
_ => {
HANDLER.with(|handler| {
handler
.struct_span_err(
cmt.span,
"Runtime must be either `classic` or `automatic`.",
)
.emit()
});
}
},
Some("@jsxImportSource") => {
if let Some(src) = val {
res.runtime = Some(Runtime::Automatic);
res.import_source = Some(Atom::new(src));
}
}
Some("@jsxFrag") => {
if let Some(src) = val {
if is_valid_for_pragma(src) {
// TODO: Optimize
let mut e = parse_expr_for_jsx(
cm,
"module-jsx-pragma-frag",
cache_source(src),
top_level_mark,
);
respan(&mut e, cmt.span);
res.pragma_frag = Some(e.into())
}
}
}
Some("@jsx") => {
if let Some(src) = val {
if is_valid_for_pragma(src) {
// TODO: Optimize
let mut e = parse_expr_for_jsx(
cm,
"module-jsx-pragma",
cache_source(src),
top_level_mark,
);
respan(&mut e, cmt.span);
res.pragma = Some(e.into());
}
}
}
_ => {}
}
}
}
}
res
}
}
#[cfg(feature = "concurrent")]
fn cache_source(src: &str) -> Lrc<String> {
static CACHE: Lazy<RwLock<FxHashMap<String, Lrc<String>>>> =
Lazy::new(|| RwLock::new(FxHashMap::default()));
{
let cache = CACHE.write().unwrap();
if let Some(cached) = cache.get(src) {
return cached.clone();
}
}
let cached = Lrc::new(src.to_string());
{
let mut cache = CACHE.write().unwrap();
cache.insert(src.to_string(), cached.clone());
}
cached
}
#[cfg(not(feature = "concurrent"))]
fn cache_source(src: &str) -> Lrc<String> {
// We cannot cache because Rc does not implement Send.
Lrc::new(src.to_string())
}
fn is_valid_for_pragma(s: &str) -> bool {
if s.is_empty() {
return false;
}
if !s.starts_with(|c: char| Ident::is_valid_start(c)) {
return false;
}
for c in s.chars() {
if !Ident::is_valid_continue(c) && c != '.' {
return false;
}
}
true
}
impl<C> Jsx<C>
where
C: Comments,
{
fn inject_runtime<T, F>(&mut self, body: &mut Vec<T>, inject: F)
where
T: StmtLike,
// Fn(Vec<(local, imported)>, src, body)
F: Fn(Vec<(Ident, IdentName)>, &str, &mut Vec<T>),
{
if self.runtime == Runtime::Automatic {
if let Some(local) = self.import_create_element.take() {
inject(
vec![(local, quote_ident!("createElement"))],
&self.import_source,
body,
);
}
let imports = self.import_jsx.take();
let imports = if self.development {
imports
.map(|local| (local, quote_ident!("jsxDEV")))
.into_iter()
.chain(
self.import_fragment
.take()
.map(|local| (local, quote_ident!("Fragment"))),
)
.collect::<Vec<_>>()
} else {
imports
.map(|local| (local, quote_ident!("jsx")))
.into_iter()
.chain(
self.import_jsxs
.take()
.map(|local| (local, quote_ident!("jsxs"))),
)
.chain(
self.import_fragment
.take()
.map(|local| (local, quote_ident!("Fragment"))),
)
.collect::<Vec<_>>()
};
if !imports.is_empty() {
let jsx_runtime = if self.development {
"jsx-dev-runtime"
} else {
"jsx-runtime"
};
let value = format!("{}/{}", self.import_source, jsx_runtime);
inject(imports, &value, body)
}
}
}
fn jsx_frag_to_expr(&mut self, el: JSXFragment) -> Expr {
let mut span = el.span();
let count = count_children(&el.children);
let use_jsxs = count > 1
|| (count == 1 && matches!(&el.children[0], JSXElementChild::JSXSpreadChild(..)));
if let Some(comments) = &self.comments {
if span.lo.is_dummy() {
span.lo = Span::dummy_with_cmt().lo;
}
comments.add_pure_comment(span.lo);
}
match self.runtime {
Runtime::Automatic => {
let jsx = if use_jsxs && !self.development {
self.import_jsxs
.get_or_insert_with(|| private_ident!("_jsxs"))
.clone()
} else {
let jsx = if self.development { "_jsxDEV" } else { "_jsx" };
self.import_jsx
.get_or_insert_with(|| private_ident!(jsx))
.clone()
};
let fragment = self
.import_fragment
.get_or_insert_with(|| private_ident!("_Fragment"))
.clone();
let mut props_obj = ObjectLit {
span: DUMMY_SP,
props: Vec::new(),
};
let children = el
.children
.into_iter()
.filter_map(|child| self.jsx_elem_child_to_expr(child))
.map(Some)
.collect::<Vec<_>>();
match (children.len(), use_jsxs) {
(0, _) => {}
(1, false) => {
props_obj
.props
.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident(quote_ident!("children")),
value: children.into_iter().next().flatten().unwrap().expr,
}))));
}
_ => {
props_obj
.props
.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident(quote_ident!("children")),
value: ArrayLit {
span: DUMMY_SP,
elems: children,
}
.into(),
}))));
}
}
let args = once(fragment.as_arg()).chain(once(props_obj.as_arg()));
let args = if self.development {
args.chain(once(Expr::undefined(DUMMY_SP).as_arg()))
.chain(once(use_jsxs.as_arg()))
.collect()
} else {
args.collect()
};
CallExpr {
span,
callee: jsx.as_callee(),
args,
..Default::default()
}
.into()
}
Runtime::Classic => {
CallExpr {
span,
callee: (*self.pragma).clone().as_callee(),
args: iter::once((*self.pragma_frag).clone().as_arg())
// attribute: null
.chain(iter::once(Lit::Null(Null { span: DUMMY_SP }).as_arg()))
.chain({
// Children
el.children
.into_iter()
.filter_map(|c| self.jsx_elem_child_to_expr(c))
})
.collect(),
..Default::default()
}
.into()
}
}
}
/// # Automatic
///
/// <div></div> => jsx('div', null);
///
/// # Classic
///
/// <div></div> => React.createElement('div', null);
fn jsx_elem_to_expr(&mut self, el: JSXElement) -> Expr {
let top_level_node = self.top_level_node;
let mut span = el.span();
let use_create_element = should_use_create_element(&el.opening.attrs);
self.top_level_node = false;
let name = self.jsx_name(el.opening.name);
if let Some(comments) = &self.comments {
if span.lo.is_dummy() {
span.lo = Span::dummy_with_cmt().lo;
}
comments.add_pure_comment(span.lo);
}
match self.runtime {
Runtime::Automatic => {
// function jsx(tagName: string, props: { children: Node[], ... }, key: string)
let count = count_children(&el.children);
let use_jsxs = count > 1
|| (count == 1
&& matches!(&el.children[0], JSXElementChild::JSXSpreadChild(..)));
let jsx = if use_create_element {
self.import_create_element
.get_or_insert_with(|| private_ident!("_createElement"))
.clone()
} else if use_jsxs && !self.development {
self.import_jsxs
.get_or_insert_with(|| private_ident!("_jsxs"))
.clone()
} else {
let jsx = if self.development { "_jsxDEV" } else { "_jsx" };
self.import_jsx
.get_or_insert_with(|| private_ident!(jsx))
.clone()
};
let mut props_obj = ObjectLit {
span: DUMMY_SP,
props: Vec::new(),
};
let mut key = None;
let mut source_props = None;
let mut self_props = None;
for attr in el.opening.attrs {
match attr {
JSXAttrOrSpread::JSXAttr(attr) => {
//
match attr.name {
JSXAttrName::Ident(i) => {
//
if !use_create_element && i.sym == "key" {
key = attr
.value
.and_then(jsx_attr_value_to_expr)
.map(|expr| expr.as_arg());
if key.is_none() {
HANDLER.with(|handler| {
handler
.struct_span_err(
i.span,
"The value of property 'key' should not \
be empty",
)
.emit();
});
}
continue;
}
if !use_create_element
&& *i.sym == *"__source"
&& self.development
{
if source_props.is_some() {
panic!("Duplicate __source is found");
}
source_props = attr
.value
.and_then(jsx_attr_value_to_expr)
.map(|expr| expr.as_arg());
assert_ne!(
source_props, None,
"value of property '__source' should not be empty"
);
continue;
}
if !use_create_element
&& *i.sym == *"__self"
&& self.development
{
if self_props.is_some() {
panic!("Duplicate __self is found");
}
self_props = attr
.value
.and_then(jsx_attr_value_to_expr)
.map(|expr| expr.as_arg());
assert_ne!(
self_props, None,
"value of property '__self' should not be empty"
);
continue;
}
let value = match attr.value {
Some(v) => jsx_attr_value_to_expr(v)
.expect("empty expression container?"),
None => true.into(),
};
// TODO: Check if `i` is a valid identifier.
let key = if i.sym.contains('-') {
PropName::Str(Str {
span: i.span,
raw: None,
value: i.sym,
})
} else {
PropName::Ident(i)
};
props_obj.props.push(PropOrSpread::Prop(Box::new(
Prop::KeyValue(KeyValueProp { key, value }),
)));
}
JSXAttrName::JSXNamespacedName(JSXNamespacedName {
ns,
name,
..
}) => {
if self.throw_if_namespace {
HANDLER.with(|handler| {
handler
.struct_span_err(
span,
"JSX Namespace is disabled by default because \
react does not support it yet. You can \
specify jsc.transform.react.throwIfNamespace \
to false to override default behavior",
)
.emit()
});
}
let value = match attr.value {
Some(v) => jsx_attr_value_to_expr(v)
.expect("empty expression container?"),
None => true.into(),
};
let str_value = format!("{}:{}", ns.sym, name.sym);
let key = Str {
span,
raw: None,
value: str_value.into(),
};
let key = PropName::Str(key);
props_obj.props.push(PropOrSpread::Prop(Box::new(
Prop::KeyValue(KeyValueProp { key, value }),
)));
}
}
}
JSXAttrOrSpread::SpreadElement(attr) => match *attr.expr {
Expr::Object(obj) => {
props_obj.props.extend(obj.props);
}
_ => {
props_obj.props.push(PropOrSpread::Spread(attr));
}
},
}
}
let mut children = el
.children
.into_iter()
.filter_map(|child| self.jsx_elem_child_to_expr(child))
.map(Some)
.collect::<Vec<_>>();
match children.len() {
0 => {}
1 if children[0].as_ref().unwrap().spread.is_none() => {
if !use_create_element {
props_obj
.props
.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident(quote_ident!("children")),
value: children
.take()
.into_iter()
.next()
.flatten()
.unwrap()
.expr,
}))));
}
}
_ => {
props_obj
.props
.push(PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident(quote_ident!("children")),
value: ArrayLit {
span: DUMMY_SP,
elems: children.take(),
}
.into(),
}))));
}
}
self.top_level_node = top_level_node;
let args = once(name.as_arg()).chain(once(props_obj.as_arg()));
let args = if use_create_element {
args.chain(children.into_iter().flatten()).collect()
} else if self.development {
// set undefined literal to key if key is None
let key = match key {
Some(key) => key,
None => Expr::undefined(DUMMY_SP).as_arg(),
};
// set undefined literal to __source if __source is None
let source_props = match source_props {
Some(source_props) => source_props,
None => Expr::undefined(DUMMY_SP).as_arg(),
};
// set undefined literal to __self if __self is None
let self_props = match self_props {
Some(self_props) => self_props,
None => Expr::undefined(DUMMY_SP).as_arg(),
};
args.chain(once(key))
.chain(once(use_jsxs.as_arg()))
.chain(once(source_props))
.chain(once(self_props))
.collect()
} else {
args.chain(key).collect()
};
CallExpr {
span,
callee: jsx.as_callee(),
args,
..Default::default()
}
.into()
}
Runtime::Classic => {
CallExpr {
span,
callee: (*self.pragma).clone().as_callee(),
args: iter::once(name.as_arg())
.chain(iter::once({
// Attributes
self.fold_attrs_for_classic(el.opening.attrs).as_arg()
}))
.chain({
// Children
el.children
.into_iter()
.filter_map(|c| self.jsx_elem_child_to_expr(c))
})
.collect(),
..Default::default()
}
.into()
}
}
}
fn jsx_elem_child_to_expr(&mut self, c: JSXElementChild) -> Option<ExprOrSpread> {
self.top_level_node = false;
Some(match c {
JSXElementChild::JSXText(text) => {
// TODO(kdy1): Optimize
let value = jsx_text_to_str(text.value);
let s = Str {
span: text.span,
raw: None,
value,
};
if s.value.is_empty() {
return None;
}
Lit::Str(s).as_arg()
}
JSXElementChild::JSXExprContainer(JSXExprContainer {
expr: JSXExpr::Expr(e),
..
}) => e.as_arg(),
JSXElementChild::JSXExprContainer(JSXExprContainer {
expr: JSXExpr::JSXEmptyExpr(..),
..
}) => return None,
JSXElementChild::JSXElement(el) => self.jsx_elem_to_expr(*el).as_arg(),
JSXElementChild::JSXFragment(el) => self.jsx_frag_to_expr(el).as_arg(),
JSXElementChild::JSXSpreadChild(JSXSpreadChild { span, expr, .. }) => ExprOrSpread {
spread: Some(span),
expr,
},
})
}
fn fold_attrs_for_classic(&mut self, attrs: Vec<JSXAttrOrSpread>) -> Box<Expr> {
if attrs.is_empty() {
return Lit::Null(Null { span: DUMMY_SP }).into();
}
let attr_cnt = attrs.len();
let mut props = Vec::new();
for attr in attrs {
match attr {
JSXAttrOrSpread::JSXAttr(attr) => {
props.push(PropOrSpread::Prop(Box::new(self.attr_to_prop(attr))))
}
JSXAttrOrSpread::SpreadElement(spread) => {
if attr_cnt == 1 {
return spread.expr;
}
// babel does some optimizations
match *spread.expr {
Expr::Object(obj) => props.extend(obj.props),
_ => props.push(PropOrSpread::Spread(spread)),
}
}
}
}
let obj = ObjectLit {
span: DUMMY_SP,
props,
};
obj.into()
}
fn attr_to_prop(&mut self, a: JSXAttr) -> Prop {
let key = to_prop_name(a.name);
let value = a
.value
.map(|v| match v {
JSXAttrValue::Lit(Lit::Str(s)) => {
let value = transform_jsx_attr_str(&s.value);
Lit::Str(Str {
span: s.span,
raw: None,
value: value.into(),
})
.into()
}
JSXAttrValue::JSXExprContainer(JSXExprContainer {
expr: JSXExpr::Expr(e),
..
}) => e,
JSXAttrValue::JSXElement(element) => Box::new(self.jsx_elem_to_expr(*element)),
JSXAttrValue::JSXFragment(fragment) => Box::new(self.jsx_frag_to_expr(fragment)),
JSXAttrValue::Lit(lit) => Box::new(lit.into()),
JSXAttrValue::JSXExprContainer(JSXExprContainer {
span: _,
expr: JSXExpr::JSXEmptyExpr(_),
}) => unreachable!("attr_to_prop(JSXEmptyExpr)"),
})
.unwrap_or_else(|| {
Lit::Bool(Bool {
span: key.span(),
value: true,
})
.into()
});
Prop::KeyValue(KeyValueProp { key, value })
}
}
impl<C> Jsx<C>
where
C: Comments,
{
/// If we found required jsx directives, we returns true.
fn parse_directives(&mut self, span: Span) -> bool {
let mut found = false;
let directives = self.comments.with_leading(span.lo, |comments| {
JsxDirectives::from_comments(&self.cm, span, comments, self.top_level_mark)
});
let JsxDirectives {
runtime,
import_source,
pragma,
pragma_frag,
} = directives;
if let Some(runtime) = runtime {
found = true;
self.runtime = runtime;
}
if let Some(import_source) = import_source {
found = true;
self.import_source = import_source;
}
if let Some(pragma) = pragma {
if let Runtime::Automatic = self.runtime {
HANDLER.with(|handler| {
handler
.struct_span_err(
pragma.span(),
"pragma cannot be set when runtime is automatic",
)
.emit()
});
}
found = true;
self.pragma = pragma;
}
if let Some(pragma_frag) = pragma_frag {
if let Runtime::Automatic = self.runtime {
HANDLER.with(|handler| {
handler
.struct_span_err(
pragma_frag.span(),
"pragmaFrag cannot be set when runtime is automatic",
)
.emit()
});
}
found = true;
self.pragma_frag = pragma_frag;
}
found
}
}
impl<C> VisitMut for Jsx<C>
where
C: Comments,
{
noop_visit_mut_type!();
fn visit_mut_expr(&mut self, expr: &mut Expr) {
let top_level_node = self.top_level_node;
let mut did_work = false;
if let Expr::JSXElement(el) = expr {
did_work = true;
// <div></div> => React.createElement('div', null);
*expr = self.jsx_elem_to_expr(*el.take());
} else if let Expr::JSXFragment(frag) = expr {
// <></> => React.createElement(React.Fragment, null);
did_work = true;
*expr = self.jsx_frag_to_expr(frag.take());
} else if let Expr::Paren(ParenExpr {
expr: inner_expr, ..
}) = expr
{
if let Expr::JSXElement(el) = &mut **inner_expr {
did_work = true;
*expr = self.jsx_elem_to_expr(*el.take());
} else if let Expr::JSXFragment(frag) = &mut **inner_expr {
// <></> => React.createElement(React.Fragment, null);
did_work = true;
*expr = self.jsx_frag_to_expr(frag.take());
}
}
if did_work {
self.top_level_node = false;
}
expr.visit_mut_children_with(self);
self.top_level_node = top_level_node;
}
fn visit_mut_module(&mut self, module: &mut Module) {
self.parse_directives(module.span);
for item in &module.body {
let span = item.span();
if self.parse_directives(span) {
break;
}
}
module.visit_mut_children_with(self);
if self.runtime == Runtime::Automatic {
self.inject_runtime(&mut module.body, |imports, src, stmts| {
let specifiers = imports
.into_iter()
.map(|(local, imported)| {
ImportSpecifier::Named(ImportNamedSpecifier {
span: DUMMY_SP,
local,
imported: Some(ModuleExportName::Ident(imported.into())),
is_type_only: false,
})
})
.collect();
prepend_stmt(
stmts,
ImportDecl {
span: DUMMY_SP,
specifiers,
src: Str {
span: DUMMY_SP,
raw: None,
value: src.into(),
}
.into(),
type_only: Default::default(),
with: Default::default(),
phase: Default::default(),
}
.into(),
)
});
}
}
fn visit_mut_script(&mut self, script: &mut Script) {
self.parse_directives(script.span);
for item in &script.body {
let span = item.span();
if self.parse_directives(span) {
break;
}
}
script.visit_mut_children_with(self);
if self.runtime == Runtime::Automatic {
let mark = self.unresolved_mark;
self.inject_runtime(&mut script.body, |imports, src, stmts| {
prepend_stmt(stmts, add_require(imports, src, mark))
});
}
}
}
// const { createElement } = require('react')
// const { jsx: jsx } = require('react/jsx-runtime')
fn add_require(imports: Vec<(Ident, IdentName)>, src: &str, unresolved_mark: Mark) -> Stmt {
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Object(ObjectPat {
span: DUMMY_SP,
props: imports
.into_iter()
.map(|(local, imported)| {
if imported.sym != local.sym {
ObjectPatProp::KeyValue(KeyValuePatProp {
key: PropName::Ident(imported),
value: Box::new(Pat::Ident(local.into())),
})
} else {
ObjectPatProp::Assign(AssignPatProp {
span: DUMMY_SP,
key: local.into(),
value: None,
})
}
})
.collect(),
optional: false,
type_ann: None,
}),
// require('react')
init: Some(Box::new(Expr::Call(CallExpr {
span: DUMMY_SP,
callee: Callee::Expr(Box::new(Expr::Ident(Ident {
ctxt: SyntaxContext::empty().apply_mark(unresolved_mark),
sym: "require".into(),
optional: false,
..Default::default()
}))),
args: vec![ExprOrSpread {
spread: None,
expr: Box::new(Expr::Lit(Lit::Str(Str {
span: DUMMY_SP,
value: src.into(),
raw: None,
}))),
}],
..Default::default()
}))),
definite: false,
}],
..Default::default()
}
.into()
}
impl<C> Jsx<C>
where
C: Comments,
{
fn jsx_name(&self, name: JSXElementName) -> Box<Expr> {
let span = name.span();
match name {
JSXElementName::Ident(i) => {
if i.sym == "this" {
return ThisExpr { span }.into();
}
// If it starts with lowercase
if i.as_ref().starts_with(|c: char| c.is_ascii_lowercase()) {
Lit::Str(Str {
span,
raw: None,
value: i.sym,
})
.into()
} else {
i.into()
}
}
JSXElementName::JSXNamespacedName(JSXNamespacedName {
ref ns, ref name, ..
}) => {
if self.throw_if_namespace {
HANDLER.with(|handler| {
handler
.struct_span_err(
span,
"JSX Namespace is disabled by default because react does not \
support it yet. You can specify \
jsc.transform.react.throwIfNamespace to false to override \
default behavior",
)
.emit()
});
}
let value = format!("{}:{}", ns.sym, name.sym);
Lit::Str(Str {
span,
raw: None,
value: value.into(),
})
.into()
}
JSXElementName::JSXMemberExpr(JSXMemberExpr { obj, prop, .. }) => {
fn convert_obj(obj: JSXObject) -> Box<Expr> {
let span = obj.span();
(match obj {
JSXObject::Ident(i) => {
if i.sym == "this" {
Expr::This(ThisExpr { span })
} else {
i.into()
}
}
JSXObject::JSXMemberExpr(e) => MemberExpr {
span,
obj: convert_obj(e.obj),
prop: MemberProp::Ident(e.prop),
}
.into(),
})
.into()
}
MemberExpr {
span,
obj: convert_obj(obj),
prop: MemberProp::Ident(prop),
}
.into()
}
}
}
}
fn to_prop_name(n: JSXAttrName) -> PropName {
let span = n.span();
match n {
JSXAttrName::Ident(i) => {
if i.sym.contains('-') {
PropName::Str(Str {
span,
raw: None,
value: i.sym,
})
} else {
PropName::Ident(i)
}
}
JSXAttrName::JSXNamespacedName(JSXNamespacedName { ns, name, .. }) => {
let value = format!("{}:{}", ns.sym, name.sym);
PropName::Str(Str {
span,
raw: None,
value: value.into(),
})
}
}
}
#[inline]
fn jsx_text_to_str(t: Atom) -> Atom {
let mut buf = String::new();
let replaced = t.replace('\t', " ");
for (is_last, (i, line)) in replaced.lines().enumerate().identify_last() {
if line.is_empty() {
continue;
}
let line = Cow::from(line);
let line = if i != 0 {
Cow::Borrowed(line.trim_start_matches(' '))
} else {
line
};
let line = if is_last {
line
} else {
Cow::Borrowed(line.trim_end_matches(' '))
};
if line.len() == 0 {
continue;
}
if i != 0 && !buf.is_empty() {
buf.push(' ')
}
buf.push_str(&line);
}
buf.into()
}
fn jsx_attr_value_to_expr(v: JSXAttrValue) -> Option<Box<Expr>> {
Some(match v {
JSXAttrValue::Lit(Lit::Str(s)) => {
let value = transform_jsx_attr_str(&s.value);
Lit::Str(Str {
span: s.span,
raw: None,
value: value.into(),
})
.into()
}
JSXAttrValue::Lit(lit) => Box::new(lit.into()),
JSXAttrValue::JSXExprContainer(e) => match e.expr {
JSXExpr::JSXEmptyExpr(_) => None?,
JSXExpr::Expr(e) => e,
},
JSXAttrValue::JSXElement(e) => e.into(),
JSXAttrValue::JSXFragment(f) => f.into(),
})
}
fn count_children(children: &[JSXElementChild]) -> usize {
children
.iter()
.filter(|v| match v {
JSXElementChild::JSXText(text) => {
let text = jsx_text_to_str(text.value.clone());
!text.is_empty()
}
JSXElementChild::JSXExprContainer(e) => match e.expr {
JSXExpr::JSXEmptyExpr(_) => false,
JSXExpr::Expr(_) => true,
},
JSXElementChild::JSXSpreadChild(_) => true,
JSXElementChild::JSXElement(_) => true,
JSXElementChild::JSXFragment(_) => true,
})
.count()
}
fn transform_jsx_attr_str(v: &str) -> String {
let single_quote = false;
let mut buf = String::with_capacity(v.len());
let mut iter = v.chars().peekable();
while let Some(c) = iter.next() {
match c {
'\u{0008}' => buf.push_str("\\b"),
'\u{000c}' => buf.push_str("\\f"),
' ' => buf.push(' '),
'\n' | '\r' | '\t' => {
buf.push(' ');
while let Some(' ') = iter.peek() {
iter.next();
}
}
'\u{000b}' => buf.push_str("\\v"),
'\0' => buf.push_str("\\x00"),
'\'' if single_quote => buf.push_str("\\'"),
'"' if !single_quote => buf.push('\"'),
'\x01'..='\x0f' | '\x10'..='\x1f' => {
buf.push(c);
}
'\x20'..='\x7e' => {
//
buf.push(c);
}
'\u{7f}'..='\u{ff}' => {
buf.push(c);
}
_ => {
buf.push(c);
}
}
}
buf
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/jsx/static_check.rs | Rust | use swc_ecma_ast::*;
/// We want to use React.createElement, even in the case of
/// jsx, for <div {...props} key={key} /> to distinguish it
/// from <div key={key} {...props} />. This is an intermediary
/// step while we deprecate key spread from props. Afterwards,
/// we will stop using createElement in the transform.
pub(super) fn should_use_create_element(attrs: &[JSXAttrOrSpread]) -> bool {
let mut seen_prop_spread = false;
for attr in attrs {
if seen_prop_spread
&& match attr {
JSXAttrOrSpread::JSXAttr(attr) => match &attr.name {
JSXAttrName::Ident(i) => i.sym == "key",
JSXAttrName::JSXNamespacedName(_) => false,
},
_ => false,
}
{
return true;
}
if let JSXAttrOrSpread::SpreadElement(_) = attr {
seen_prop_spread = true;
}
}
false
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/jsx/tests.rs | Rust | #![allow(dead_code)]
use std::{
fs,
path::{Path, PathBuf},
};
use swc_ecma_codegen::{Config, Emitter};
use swc_ecma_parser::{EsSyntax, Parser, StringInput};
use swc_ecma_transforms_base::{fixer::fixer, hygiene, resolver};
use swc_ecma_transforms_compat::{
es2015::{arrow, classes},
es3::property_literals,
};
use swc_ecma_transforms_testing::{parse_options, test, test_fixture, FixtureTestConfig, Tester};
use testing::NormalizedOutput;
use super::*;
use crate::{display_name, pure_annotations, react};
fn tr(t: &mut Tester, options: Options, top_level_mark: Mark) -> impl Pass {
let unresolved_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
jsx(
t.cm.clone(),
Some(t.comments.clone()),
options,
top_level_mark,
unresolved_mark,
),
display_name(),
classes(Default::default()),
arrow(unresolved_mark),
)
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct FixtureOptions {
#[serde(flatten)]
options: Options,
#[serde(default, rename = "BABEL_8_BREAKING")]
babel_8_breaking: bool,
#[serde(default = "true_by_default")]
pure: bool,
#[serde(default)]
throws: Option<String>,
#[serde(default, alias = "useBuiltIns")]
use_builtins: bool,
}
fn true_by_default() -> bool {
true
}
fn fixture_tr(t: &mut Tester, mut options: FixtureOptions) -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
options.options.next = Some(options.babel_8_breaking || options.options.runtime.is_some());
if !options.babel_8_breaking && options.options.runtime.is_none() {
options.options.runtime = Some(Runtime::Classic);
}
(
resolver(unresolved_mark, top_level_mark, false),
jsx(
t.cm.clone(),
Some(t.comments.clone()),
options.options,
top_level_mark,
unresolved_mark,
),
display_name(),
pure_annotations(Some(t.comments.clone())),
)
}
fn integration_tr(t: &mut Tester, mut options: FixtureOptions) -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
options.options.next = Some(options.babel_8_breaking || options.options.runtime.is_some());
if !options.babel_8_breaking && options.options.runtime.is_none() {
options.options.runtime = Some(Runtime::Classic);
}
(
resolver(unresolved_mark, top_level_mark, false),
react(
t.cm.clone(),
Some(t.comments.clone()),
options.options,
top_level_mark,
unresolved_mark,
),
display_name(),
)
}
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_add_appropriate_newlines,
r#"
<Component
{...props}
sound="moo" />
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_arrow_functions,
r#"
var foo = function () {
return () => <this />;
};
var bar = function () {
return () => <this.foo />;
};
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_concatenates_adjacent_string_literals,
r#"
var x =
<div>
foo
{"bar"}
baz
<div>
buz
bang
</div>
qux
{null}
quack
</div>
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_display_name_assignment_expression,
r#"var Component;
Component = React.createClass({
render: function render() {
return null;
}
});"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_display_name_export_default,
r#"
export default React.createClass({
render: function render() {
return null;
}
});
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_display_name_if_missing,
r#"
var Whateva = React.createClass({
displayName: "Whatever",
render: function render() {
return null;
}
});
var Bar = React.createClass({
"displayName": "Ba",
render: function render() {
return null;
}
});
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_display_name_object_declaration,
r#"
exports = {
Component: React.createClass({
render: function render() {
return null;
}
})
};"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_display_name_property_assignment,
r#"
exports.Component = React.createClass({
render: function render() {
return null;
}
});
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_display_name_variable_declaration,
r#"
var Component = React.createClass({
render: function render() {
return null;
}
});
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_dont_coerce_expression_containers,
r#"
<Text>
To get started, edit index.ios.js!!!{"\n"}
Press Cmd+R to reload
</Text>
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_honor_custom_jsx_comment_if_jsx_pragma_option_set,
r#"/** @jsx dom */
<Foo></Foo>;
var profile = <div>
<img src="avatar.png" className="profile" />
<h3>{[user.firstName, user.lastName].join(" ")}</h3>
</div>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_honor_custom_jsx_comment,
r#"
/** @jsx dom */
<Foo></Foo>;
var profile = <div>
<img src="avatar.png" className="profile" />
<h3>{[user.firstName, user.lastName].join(" ")}</h3>
</div>;
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(
t,
Options {
pragma: Some(Lrc::new("dom".into())),
..Default::default()
},
Mark::fresh(Mark::root())
),
react_honor_custom_jsx_pragma_option,
r#"
<Foo></Foo>;
var profile = <div>
<img src="avatar.png" className="profile" />
<h3>{[user.firstName, user.lastName].join(" ")}</h3>
</div>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_jsx_with_retainlines_option,
r#"var div = <div>test</div>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_jsx_without_retainlines_option,
r#"var div = <div>test</div>;"#
);
test!(
// Optimization is not implemented yet
ignore,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_optimisation_react_constant_elements,
r#"
class App extends React.Component {
render() {
const navbarHeader = <div className="navbar-header">
<a className="navbar-brand" href="/">
<img src="/img/logo/logo-96x36.png" />
</a>
</div>;
return <div>
<nav className="navbar navbar-default">
<div className="container">
{navbarHeader}
</div>
</nav>
</div>;
}
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| (
tr(t, Default::default(), Mark::fresh(Mark::root())),
property_literals(),
),
react_should_add_quotes_es3,
r#"var es3 = <F aaa new const var default foo-bar/>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_allow_constructor_as_prop,
r#"<Component constructor="foo" />;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_allow_deeper_js_namespacing,
r#"<Namespace.DeepNamespace.Component />;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_allow_elements_as_attributes,
r#"<div attr=<div /> />"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_allow_js_namespacing,
r#"<Namespace.Component />;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_allow_nested_fragments,
r#"
<div>
< >
<>
<span>Hello</span>
<span>world</span>
</>
<>
<span>Goodbye</span>
<span>world</span>
</>
</>
</div>
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_allow_no_pragmafrag_if_frag_unused,
r#"
/** @jsx dom */
<div>no fragment is used</div>
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_allow_pragmafrag_and_frag,
r#"
/** @jsx dom */
/** @jsxFrag DomFrag */
<></>
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_avoid_wrapping_in_extra_parens_if_not_needed,
r#"
var x = <div>
<Component />
</div>;
var x = <div>
{props.children}
</div>;
var x = <Composite>
{props.children}
</Composite>;
var x = <Composite>
<Composite2 />
</Composite>;
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_convert_simple_tags,
r#"var x = <div></div>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_convert_simple_text,
r#"var x = <div>text</div>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_escape_xhtml_jsxattribute,
r#"
<div id="wôw" />;
<div id="\w" />;
<div id="w < w" />;
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_escape_xhtml_jsxtext_1,
r"
<div>wow</div>;
<div>wôw</div>;
<div>w & w</div>;
<div>w & w</div>;
<div>w w</div>;
<div>this should parse as unicode: {'\u00a0 '}</div>;
<div>w < w</div>;
"
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_escape_xhtml_jsxtext_2,
r"
<div>this should not parse as unicode: \u00a0</div>;
"
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_escape_unicode_chars_in_attribute,
r#"<Bla title="Ú"/>"#
);
test!(
// FIXME
ignore,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_escape_xhtml_jsxtext_3,
r#"
<div>this should parse as nbsp: </div>;
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_handle_attributed_elements,
r#"
var HelloMessage = React.createClass({
render: function() {
return <div>Hello {this.props.name}</div>;
}
});
React.render(<HelloMessage name={
<span>
Sebastian
</span>
} />, mountNode);
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_handle_has_own_property_correctly,
r#"<hasOwnProperty>testing</hasOwnProperty>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_have_correct_comma_in_nested_children,
r#"
var x = <div>
<div><br /></div>
<Component>{foo}<br />{bar}</Component>
<br />
</div>;
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_insert_commas_after_expressions_before_whitespace,
r#"
var x =
<div
attr1={
"foo" + "bar"
}
attr2={
"foo" + "bar" +
"baz" + "bug"
}
attr3={
"foo" + "bar" +
"baz" + "bug"
}
attr4="baz">
</div>
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_not_add_quotes_to_identifier_names,
r#"var e = <F aaa new const var default foo-bar/>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_not_mangle_expressioncontainer_attribute_values,
r#"<button data-value={"a value\n with\nnewlines\n and spaces"}>Button</button>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_not_strip_nbsp_even_coupled_with_other_whitespace,
r#"<div> </div>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_not_strip_tags_with_a_single_child_of_nbsp,
r#"<div> </div>;"#
);
test!(
module,
// Comments are currently stripped out
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_properly_handle_comments_between_props,
r#"
var x = (
<div
/* a multi-line
comment */
attr1="foo">
<span // a double-slash comment
attr2="bar"
/>
</div>
);
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_quote_jsx_attributes,
r#"<button data-value='a value'>Button</button>;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(
t,
Options {
pragma: Some(Lrc::new("h".into())),
throw_if_namespace: false.into(),
..Default::default()
},
Mark::fresh(Mark::root())
),
react_should_support_xml_namespaces_if_flag,
r#"<f:image n:attr />;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_should_transform_known_hyphenated_tags,
r#"<font-face />;"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_wraps_props_in_react_spread_for_first_spread_attributes,
r#"
<Component { ... x } y
={2 } z />
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_wraps_props_in_react_spread_for_last_spread_attributes,
r#"<Component y={2} z { ... x } />"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_wraps_props_in_react_spread_for_middle_spread_attributes,
r#"<Component y={2} { ... x } z />"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
react_attribute_html_entity_quote,
r#"<Component text="Hello "World"" />"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
use_builtins_assignment,
r#"var div = <Component {...props} foo="bar" />"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
use_spread_assignment,
r#"<Component y={2} { ...x } z />"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
issue_229,
"const a = <>test</>
const b = <div>test</div>"
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| {
let top_level_mark = Mark::fresh(Mark::root());
tr(t, Default::default(), top_level_mark)
},
issue_351,
"import React from 'react';
<div />;"
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
issue_481,
"<span> {foo}</span>;"
);
// https://github.com/swc-project/swc/issues/517
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| {
let top_level_mark = Mark::fresh(Mark::root());
tr(t, Default::default(), top_level_mark)
},
issue_517,
"import React from 'react';
<div style='white-space: pre'>Hello World</div>;"
);
#[test]
fn jsx_text() {
assert_eq!(jsx_text_to_str(" ".into()), *" ");
assert_eq!(jsx_text_to_str("Hello world".into()), *"Hello world");
// assert_eq!(jsx_text_to_str(" \n".into()), *" ");
}
// https://github.com/swc-project/swc/issues/542
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| tr(t, Default::default(), Mark::fresh(Mark::root())),
issue_542,
"let page = <p>Click <em>New melody</em> listen to a randomly generated melody</p>"
);
// regression_2775
test!(
// Module
ignore,
Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
}),
|t| {
let top_level_mark = Mark::fresh(Mark::root());
let unresolved_mark = Mark::fresh(Mark::root());
(
classes(Default::default()),
jsx(
t.cm.clone(),
Some(t.comments.clone()),
Default::default(),
top_level_mark,
unresolved_mark,
),
)
},
regression_2775,
r#"
import React, {Component} from 'react';
export default class RandomComponent extends Component {
constructor(){
super();
}
render() {
return (
<div className='sui-RandomComponent'>
<h2>Hi there!</h2>
</div>
);
}
}
"#
);
test!(
module,
Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
}),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
jsx(
t.cm.clone(),
Some(t.comments.clone()),
Default::default(),
top_level_mark,
unresolved_mark,
),
)
},
issue_4956,
"
<div title=\"\u{2028}\"/>
"
);
#[testing::fixture("tests/jsx/fixture/**/input.js")]
fn fixture(input: PathBuf) {
let mut output = input.with_file_name("output.js");
if !output.exists() {
output = input.with_file_name("output.mjs");
}
test_fixture(
Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
}),
&|t| {
let options = parse_options(input.parent().unwrap());
fixture_tr(t, options)
},
&input,
&output,
FixtureTestConfig {
allow_error: true,
module: Some(true),
..Default::default()
},
);
}
#[testing::fixture("tests/integration/fixture/**/input.js")]
fn integration(input: PathBuf) {
let mut output = input.with_file_name("output.js");
if !output.exists() {
output = input.with_file_name("output.mjs");
}
test_fixture(
Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
}),
&|t| {
let options = parse_options(input.parent().unwrap());
integration_tr(t, options)
},
&input,
&output,
FixtureTestConfig {
allow_error: true,
module: Some(true),
..Default::default()
},
);
}
#[testing::fixture("tests/script/**/input.js")]
fn script(input: PathBuf) {
let output = input.with_file_name("output.js");
let options = parse_options(input.parent().unwrap());
let input = fs::read_to_string(&input).unwrap();
test_script(&input, &output, options);
}
fn test_script(src: &str, output: &Path, options: Options) {
Tester::run(|tester| {
let fm = tester
.cm
.new_source_file(FileName::Real("input.js".into()).into(), src.into());
let syntax = Syntax::Es(EsSyntax {
jsx: true,
..Default::default()
});
let mut parser = Parser::new(syntax, StringInput::from(&*fm), Some(&tester.comments));
let script = parser.parse_script().unwrap();
let top_level_mark = Mark::new();
let unresolved_mark = Mark::new();
let script = Program::Script(script).apply((
resolver(Mark::new(), top_level_mark, false),
react(
tester.cm.clone(),
Some(&tester.comments),
options,
top_level_mark,
unresolved_mark,
),
hygiene::hygiene(),
fixer(Some(&tester.comments)),
));
let mut buf = Vec::new();
let mut emitter = Emitter {
cfg: Config::default()
.with_ascii_only(true)
.with_omit_last_semi(true),
cm: tester.cm.clone(),
wr: Box::new(swc_ecma_codegen::text_writer::JsWriter::new(
tester.cm.clone(),
"\n",
&mut buf,
None,
)),
comments: Some(&tester.comments),
};
// println!("Emitting: {:?}", module);
emitter.emit_program(&script).unwrap();
let s = String::from_utf8_lossy(&buf).to_string();
assert!(NormalizedOutput::new_raw(s).compare_to_file(output).is_ok());
Ok(())
})
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/jsx_self/mod.rs | Rust | use swc_common::DUMMY_SP;
use swc_ecma_ast::*;
use swc_ecma_transforms_base::perf::Parallel;
use swc_ecma_utils::quote_ident;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
#[cfg(test)]
mod tests;
/// `@babel/plugin-transform-react-jsx-self`
///
/// Add a __self prop to all JSX Elements
pub fn jsx_self(dev: bool) -> impl Pass {
visit_mut_pass(JsxSelf {
dev,
ctx: Default::default(),
})
}
/// See <https://github.com/babel/babel/blob/1bdb1a4175ed1fc40751fb84dc4ad1900260f28f/packages/babel-plugin-transform-react-jsx-self/src/index.ts#L27>
#[derive(Clone, Copy, Default)]
struct Context {
in_constructor: bool,
in_derived_class: bool,
}
#[derive(Clone, Copy)]
struct JsxSelf {
dev: bool,
ctx: Context,
}
impl JsxSelf {
fn with_in_constructor<N: VisitMutWith<JsxSelf>>(&mut self, in_constructor: bool, n: &mut N) {
let old = self.ctx;
self.ctx.in_constructor = in_constructor;
n.visit_mut_children_with(self);
self.ctx = old;
}
}
impl Parallel for JsxSelf {
fn create(&self) -> Self {
*self
}
fn merge(&mut self, _: Self) {}
}
impl VisitMut for JsxSelf {
noop_visit_mut_type!();
fn visit_mut_class(&mut self, n: &mut Class) {
let old = self.ctx;
self.ctx.in_derived_class = n.super_class.is_some();
n.visit_mut_children_with(self);
self.ctx = old;
}
fn visit_mut_fn_decl(&mut self, n: &mut FnDecl) {
self.with_in_constructor(false, n);
}
fn visit_mut_fn_expr(&mut self, n: &mut FnExpr) {
self.with_in_constructor(false, n);
}
fn visit_mut_prop(&mut self, n: &mut Prop) {
match n {
Prop::Getter(_) | Prop::Setter(_) | Prop::Method(_) => {
self.with_in_constructor(false, n)
}
_ => n.visit_mut_children_with(self),
}
}
fn visit_mut_class_member(&mut self, n: &mut ClassMember) {
match n {
ClassMember::Constructor(_) => self.with_in_constructor(true, n),
ClassMember::Method(_)
| ClassMember::PrivateMethod(_)
| ClassMember::StaticBlock(_) => self.with_in_constructor(false, n),
_ => n.visit_mut_children_with(self),
}
}
fn visit_mut_jsx_opening_element(&mut self, n: &mut JSXOpeningElement) {
if !self.dev {
return;
}
// https://github.com/babel/babel/blob/1bdb1a4175ed1fc40751fb84dc4ad1900260f28f/packages/babel-plugin-transform-react-jsx-self/src/index.ts#L50
if self.ctx.in_constructor && self.ctx.in_derived_class {
return;
}
n.attrs.push(JSXAttrOrSpread::JSXAttr(JSXAttr {
span: DUMMY_SP,
name: JSXAttrName::Ident(quote_ident!("__self")),
value: Some(JSXAttrValue::JSXExprContainer(JSXExprContainer {
span: DUMMY_SP,
expr: JSXExpr::Expr(Box::new(ThisExpr { span: DUMMY_SP }.into())),
})),
}));
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/jsx_self/tests.rs | Rust | use swc_common::Mark;
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_compat::es2015::arrow;
use swc_ecma_transforms_testing::test;
use super::*;
fn tr() -> impl Pass {
jsx_self(true)
}
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|_| tr(),
basic_sample,
r#"var x = <sometag />"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|_| tr(),
disable_with_super,
r#"class A { }
class B extends A {
constructor() {
<sometag1 />;
super(<sometag2 />);
<sometag3 />;
}
}
class C {
constructor() {
<sometag4 />;
class D extends A {
constructor() {
super();
}
}
const E = class extends A {
constructor() {
super();
}
};
}
}
class E extends A {
constructor() {
this.x = () => <sometag5 />;
this.y = function () {
return <sometag6 />;
};
function z() {
return <sometag7 />;
}
{ <sometag8 /> }
super();
}
}
class F {
constructor() {
<sometag9 />
}
}
class G extends A {
constructor() {
return <sometag10 />;
}
}"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|_| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
tr(),
arrow(unresolved_mark),
)
},
arrow_function,
r#"<div />;
() => <div />;
function fn() {
<div />;
() => <div />;
}"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/jsx_src/mod.rs | Rust | use swc_common::{sync::Lrc, SourceMap, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_transforms_base::perf::Parallel;
use swc_ecma_utils::quote_ident;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
#[cfg(test)]
mod tests;
/// `@babel/plugin-transform-react-jsx-source`
pub fn jsx_src(dev: bool, cm: Lrc<SourceMap>) -> impl Pass {
visit_mut_pass(JsxSrc { cm, dev })
}
#[derive(Clone)]
struct JsxSrc {
cm: Lrc<SourceMap>,
dev: bool,
}
impl Parallel for JsxSrc {
fn create(&self) -> Self {
self.clone()
}
fn merge(&mut self, _: Self) {}
}
impl VisitMut for JsxSrc {
noop_visit_mut_type!();
fn visit_mut_jsx_opening_element(&mut self, e: &mut JSXOpeningElement) {
if !self.dev || e.span == DUMMY_SP {
return;
}
e.visit_mut_children_with(self);
let loc = self.cm.lookup_char_pos(e.span.lo);
let file_name = loc.file.name.to_string();
e.attrs.push(JSXAttrOrSpread::JSXAttr(JSXAttr {
span: DUMMY_SP,
name: JSXAttrName::Ident(quote_ident!("__source")),
value: Some(JSXAttrValue::JSXExprContainer(JSXExprContainer {
span: DUMMY_SP,
expr: JSXExpr::Expr(Box::new(
ObjectLit {
span: DUMMY_SP,
props: vec![
PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident(quote_ident!("fileName")),
value: Box::new(Expr::Lit(Lit::Str(Str {
span: DUMMY_SP,
raw: None,
value: file_name.into(),
}))),
}))),
PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident(quote_ident!("lineNumber")),
value: loc.line.into(),
}))),
PropOrSpread::Prop(Box::new(Prop::KeyValue(KeyValueProp {
key: PropName::Ident(quote_ident!("columnNumber")),
value: (loc.col.0 + 1).into(),
}))),
],
}
.into(),
)),
})),
}));
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/jsx_src/tests.rs | Rust | use swc_common::FilePathMapping;
use swc_ecma_transforms_testing::{test, test_exec};
use super::*;
fn tr() -> impl Pass {
let cm = Lrc::new(SourceMap::new(FilePathMapping::empty()));
jsx_src(true, cm)
}
test_exec!(
ignore,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|_| tr(),
basic_sample,
r#"
var actual = transform(
'var x = <sometag />',
Object.assign({}, opts, { filename: '/fake/path/mock.js' })
).code;
var expected = multiline([
'var _jsxFileName = "/fake/path/mock.js";',
'var x = <sometag __source={{',
' fileName: _jsxFileName,',
' lineNumber: 1',
'}} />;',
]);
expect(actual).toBe(expected);
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|_| tr(),
no_jsx,
r#"var x = 42;"#
);
test_exec!(
ignore,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|_| tr(),
with_source,
r#"
var actual = transform(
'var x = <sometag __source="custom" />;',
Object.assign({}, opts, { filename: '/fake/path/mock.js' })
).code;
var expected = 'var x = <sometag __source="custom" />;';
expect(actual).toBe(expected);
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/lib.rs | Rust | #![deny(clippy::all)]
#![allow(clippy::mutable_key_type)]
#![allow(clippy::arc_with_non_send_sync)]
#![allow(rustc::untranslatable_diagnostic_trivial)]
#![cfg_attr(not(feature = "concurrent"), allow(unused))]
use swc_common::{comments::Comments, sync::Lrc, Mark, SourceMap};
use swc_ecma_ast::Pass;
pub use self::{
display_name::display_name,
jsx::*,
jsx_self::jsx_self,
jsx_src::jsx_src,
pure_annotations::pure_annotations,
refresh::{options::RefreshOptions, refresh},
};
mod display_name;
mod jsx;
mod jsx_self;
mod jsx_src;
mod pure_annotations;
mod refresh;
/// `@babel/preset-react`
///
/// Preset for all React plugins.
///
///
/// `top_level_mark` should be [Mark] passed to
/// [swc_ecma_transforms_base::resolver::resolver_with_mark].
///
///
///
/// # Note
///
/// This pass uses [swc_ecma_utils::HANDLER].
pub fn react<C>(
cm: Lrc<SourceMap>,
comments: Option<C>,
mut options: Options,
top_level_mark: Mark,
unresolved_mark: Mark,
) -> impl Pass
where
C: Comments + Clone,
{
let Options { development, .. } = options;
let development = development.unwrap_or(false);
let refresh_options = options.refresh.take();
(
jsx_src(development, cm.clone()),
jsx_self(development),
refresh(
development,
refresh_options.clone(),
cm.clone(),
comments.clone(),
top_level_mark,
),
jsx(
cm.clone(),
comments.clone(),
options,
top_level_mark,
unresolved_mark,
),
display_name(),
pure_annotations(comments.clone()),
)
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/pure_annotations/mod.rs | Rust | use rustc_hash::FxHashMap;
use swc_atoms::Atom;
use swc_common::{comments::Comments, Span};
use swc_ecma_ast::*;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
#[cfg(test)]
mod tests;
/// A pass to add a /*#__PURE__#/ annotation to calls to known pure calls.
///
/// This pass adds a /*#__PURE__#/ annotation to calls to known pure top-level
/// React methods, so that terser and other minifiers can safely remove them
/// during dead code elimination.
/// See https://reactjs.org/docs/react-api.html
pub fn pure_annotations<C>(comments: Option<C>) -> impl Pass
where
C: Comments,
{
visit_mut_pass(PureAnnotations {
imports: Default::default(),
comments,
})
}
struct PureAnnotations<C>
where
C: Comments,
{
imports: FxHashMap<Id, (Atom, Atom)>,
comments: Option<C>,
}
impl<C> VisitMut for PureAnnotations<C>
where
C: Comments,
{
noop_visit_mut_type!();
fn visit_mut_module(&mut self, module: &mut Module) {
// Pass 1: collect imports
for item in &module.body {
if let ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = item {
let src_str = &*import.src.value;
if src_str != "react" && src_str != "react-dom" {
continue;
}
for specifier in &import.specifiers {
let src = import.src.value.clone();
match specifier {
ImportSpecifier::Named(named) => {
let imported = match &named.imported {
Some(ModuleExportName::Ident(imported)) => imported.sym.clone(),
Some(ModuleExportName::Str(..)) => named.local.sym.clone(),
None => named.local.sym.clone(),
};
self.imports.insert(named.local.to_id(), (src, imported));
}
ImportSpecifier::Default(default) => {
self.imports
.insert(default.local.to_id(), (src, "default".into()));
}
ImportSpecifier::Namespace(ns) => {
self.imports.insert(ns.local.to_id(), (src, "*".into()));
}
}
}
}
}
if self.imports.is_empty() {
return;
}
// Pass 2: add pure annotations.
module.visit_mut_children_with(self);
}
fn visit_mut_call_expr(&mut self, call: &mut CallExpr) {
let is_react_call = match &call.callee {
Callee::Expr(expr) => match &**expr {
Expr::Ident(ident) => {
if let Some((src, specifier)) = self.imports.get(&ident.to_id()) {
is_pure(src, specifier)
} else {
false
}
}
Expr::Member(member) => match &*member.obj {
Expr::Ident(ident) => {
if let Some((src, specifier)) = self.imports.get(&ident.to_id()) {
if &**specifier == "default" || &**specifier == "*" {
match &member.prop {
MemberProp::Ident(ident) => is_pure(src, &ident.sym),
_ => false,
}
} else {
false
}
} else {
false
}
}
_ => false,
},
_ => false,
},
_ => false,
};
if is_react_call {
if let Some(comments) = &self.comments {
if call.span.lo.is_dummy() {
call.span.lo = Span::dummy_with_cmt().lo;
}
comments.add_pure_comment(call.span.lo);
}
}
call.visit_mut_children_with(self);
}
}
fn is_pure(src: &Atom, specifier: &Atom) -> bool {
match &**src {
"react" => matches!(
&**specifier,
"cloneElement"
| "createContext"
| "createElement"
| "createFactory"
| "createRef"
| "forwardRef"
| "isValidElement"
| "memo"
| "lazy"
),
"react-dom" => matches!(&**specifier, "createPortal"),
_ => false,
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/pure_annotations/tests.rs | Rust | use swc_common::{comments::SingleThreadedComments, sync::Lrc, FileName, Mark, SourceMap};
use swc_ecma_codegen::{text_writer::JsWriter, Emitter};
use swc_ecma_parser::{Parser, StringInput};
use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_testing::Tester;
use super::*;
fn parse(
tester: &mut Tester,
src: &str,
) -> Result<(Program, Lrc<SourceMap>, Lrc<SingleThreadedComments>), ()> {
let syntax = ::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
});
let source_map = Lrc::new(SourceMap::default());
let source_file = source_map.new_source_file(FileName::Anon.into(), src.into());
let comments = Lrc::new(SingleThreadedComments::default());
let program = {
let mut p = Parser::new(syntax, StringInput::from(&*source_file), Some(&comments));
let res = p
.parse_module()
.map_err(|e| e.into_diagnostic(tester.handler).emit());
for e in p.take_errors() {
e.into_diagnostic(tester.handler).emit()
}
Program::Module(res?)
};
Ok((program, source_map, comments))
}
fn emit(
source_map: Lrc<SourceMap>,
comments: Lrc<SingleThreadedComments>,
program: &Program,
) -> String {
let mut src_map_buf = Vec::new();
let mut buf = std::vec::Vec::new();
{
let writer = Box::new(JsWriter::new(
source_map.clone(),
"\n",
&mut buf,
Some(&mut src_map_buf),
));
let mut emitter = Emitter {
cfg: Default::default(),
comments: Some(&comments),
cm: source_map,
wr: writer,
};
emitter.emit_program(program).unwrap();
}
String::from_utf8(buf).unwrap()
}
fn run_test(input: &str, expected: &str) {
Tester::run(|tester| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
let (actual, actual_sm, actual_comments) = parse(tester, input)?;
let actual = actual
.apply(&mut resolver(unresolved_mark, top_level_mark, false))
.apply(&mut crate::react(
actual_sm.clone(),
Some(&actual_comments),
Default::default(),
top_level_mark,
unresolved_mark,
));
let actual_src = emit(actual_sm, actual_comments, &actual);
let (expected, expected_sm, expected_comments) = parse(tester, expected)?;
let expected_src = emit(expected_sm, expected_comments, &expected);
if actual_src != expected_src {
println!(">>>>> Orig <<<<<\n{}", input);
println!(">>>>> Code <<<<<\n{}", actual_src);
panic!(
r#"assertion failed: `(left == right)`
{}"#,
::testing::diff(&actual_src, &expected_src),
);
}
Ok(())
});
}
macro_rules! test {
($test_name:ident, $input:expr, $expected:expr) => {
#[test]
fn $test_name() {
run_test($input, $expected)
}
};
}
test!(
forward_ref,
r#"
import {forwardRef} from 'react';
const Comp = forwardRef((props, ref) => null);
"#,
r#"
import {forwardRef} from 'react';
const Comp = /*#__PURE__*/ forwardRef((props, ref) => null);
"#
);
test!(
create_element,
r#"
import React from 'react';
React.createElement('div');
"#,
r#"
import React from 'react';
/*#__PURE__*/ React.createElement('div');
"#
);
test!(
create_element_jsx,
r#"
import React from 'react';
const x = <div />;
"#,
r#"
import React from 'react';
const x = /*#__PURE__*/ React.createElement("div", null);
"#
);
test!(
create_element_fragment_jsx,
r#"
import React from 'react';
const x = <><div /></>;
"#,
r#"
import React from 'react';
const x = /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement("div", null));
"#
);
test!(
clone_element,
r#"
import React from 'react';
React.cloneElement(React.createElement('div'));
"#,
r#"
import React from 'react';
/*#__PURE__*/ React.cloneElement(/*#__PURE__*/ React.createElement('div'));
"#
);
test!(
create_context,
r#"
import { createContext } from 'react';
const context = createContext({});
"#,
r#"
import { createContext } from 'react';
const context = /*#__PURE__*/createContext({});
"#
);
test!(
create_factory,
r#"
import {createFactory} from 'react';
const div = createFactory('div');
"#,
r#"
import { createFactory } from 'react';
const div = /*#__PURE__*/createFactory('div');
"#
);
test!(
create_ref,
r#"
import React from 'react';
React.createRef();
"#,
r#"
import React from 'react';
/*#__PURE__*/ React.createRef();
"#
);
test!(
is_valid_element,
r#"
import React from 'react';
const isElement = React.isValidElement(React.createElement('div'));
"#,
r#"
import React from 'react';
const isElement = /*#__PURE__*/React.isValidElement( /*#__PURE__*/React.createElement('div'));
"#
);
test!(
lazy,
r#"
import React from 'react';
const SomeComponent = React.lazy(() => import('./SomeComponent'));
"#,
r#"
import React from 'react';
const SomeComponent = /*#__PURE__*/React.lazy(() => import('./SomeComponent'));
"#
);
test!(
memo,
r#"
import React from 'react';
const Comp = React.memo((props) => null);
"#,
r#"
import React from 'react';
const Comp = /*#__PURE__*/React.memo(props => null);
"#
);
test!(
create_portal,
r#"
import * as React from 'react';
import ReactDOM from 'react-dom';
const Portal = ReactDOM.createPortal(React.createElement('div'), document.getElementById('test'));
"#,
r#"
import * as React from 'react';
import ReactDOM from 'react-dom';
const Portal = /*#__PURE__*/ReactDOM.createPortal( /*#__PURE__*/React.createElement('div'), document.getElementById('test'));
"#
);
test!(
non_pure_react,
r#"
import {useState} from 'react';
useState(2);
"#,
r#"
import {useState} from 'react';
useState(2);
"#
);
test!(
non_pure_react_dom,
r#"
import React from 'react';
import ReactDOM from 'react-dom';
ReactDOM.render(React.createElement('div'));
"#,
r#"
import React from 'react';
import ReactDOM from 'react-dom';
ReactDOM.render(/*#__PURE__*/React.createElement('div'));
"#
);
test!(
non_react_named,
r#"
import {createElement} from 'foo';
createElement('hi');
"#,
r#"
import {createElement} from 'foo';
createElement('hi');
"#
);
test!(
non_react_namespace,
r#"
import * as foo from 'foo';
foo.createElement('hi');
"#,
r#"
import * as foo from 'foo';
foo.createElement('hi');
"#
);
test!(
non_react_default,
r#"
import foo from 'foo';
foo.createElement('hi');
"#,
r#"
import foo from 'foo';
foo.createElement('hi');
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/refresh/hook.rs | Rust | use std::{fmt::Write, mem};
use base64::prelude::{Engine, BASE64_STANDARD};
use sha1::{Digest, Sha1};
use swc_common::{util::take::Take, SourceMap, SourceMapper, Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_utils::{private_ident, quote_ident, ExprFactory};
use swc_ecma_visit::{
noop_visit_mut_type, noop_visit_type, Visit, VisitMut, VisitMutWith, VisitWith,
};
use super::util::{is_builtin_hook, make_call_expr, make_call_stmt};
use crate::RefreshOptions;
// function that use hooks
struct HookSig {
handle: Ident,
// need to add an extra register, or already inlined
hooks: Vec<Hook>,
}
impl HookSig {
fn new(hooks: Vec<Hook>) -> Self {
HookSig {
handle: private_ident!("_s"),
hooks,
}
}
}
struct Hook {
callee: HookCall,
key: String,
}
// we only consider two kinds of callee as hook call
#[allow(clippy::large_enum_variant)]
enum HookCall {
Ident(Ident),
Member(Expr, IdentName), // for obj and prop
}
pub struct HookRegister<'a> {
pub options: &'a RefreshOptions,
pub ident: Vec<Ident>,
pub extra_stmt: Vec<Stmt>,
pub current_scope: Vec<SyntaxContext>,
pub cm: &'a SourceMap,
pub should_reset: bool,
}
impl HookRegister<'_> {
pub fn gen_hook_handle(&mut self) -> Stmt {
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
decls: self
.ident
.take()
.into_iter()
.map(|id| VarDeclarator {
span: DUMMY_SP,
name: id.into(),
init: Some(Box::new(make_call_expr(
quote_ident!(self.options.refresh_sig.clone()).into(),
))),
definite: false,
})
.collect(),
declare: false,
..Default::default()
}
.into()
}
// The second call is around the function itself. This is used to associate a
// type with a signature.
// Unlike with $RefreshReg$, this needs to work for nested declarations too.
fn wrap_with_register(&self, handle: Ident, func: Expr, hooks: Vec<Hook>) -> Expr {
let mut args = vec![func.as_arg()];
let mut sign = Vec::new();
let mut custom_hook = Vec::new();
for hook in hooks {
let name = match &hook.callee {
HookCall::Ident(i) => i.clone(),
HookCall::Member(_, i) => i.clone().into(),
};
sign.push(format!("{}{{{}}}", name.sym, hook.key));
match &hook.callee {
HookCall::Ident(ident) if !is_builtin_hook(&ident.sym) => {
custom_hook.push(hook.callee);
}
HookCall::Member(Expr::Ident(obj_ident), prop) if !is_builtin_hook(&prop.sym) => {
if obj_ident.sym.as_ref() != "React" {
custom_hook.push(hook.callee);
}
}
_ => (),
};
}
let sign = sign.join("\n");
let sign = if self.options.emit_full_signatures {
sign
} else {
let mut hasher = Sha1::new();
hasher.update(sign);
BASE64_STANDARD.encode(hasher.finalize())
};
args.push(
Lit::Str(Str {
span: DUMMY_SP,
raw: None,
value: sign.into(),
})
.as_arg(),
);
let mut should_reset = self.should_reset;
let mut custom_hook_in_scope = Vec::new();
for hook in custom_hook {
let ident = match &hook {
HookCall::Ident(ident) => Some(ident),
HookCall::Member(Expr::Ident(ident), _) => Some(ident),
_ => None,
};
if !ident
.map(|id| self.current_scope.contains(&id.ctxt))
.unwrap_or(false)
{
// We don't have anything to put in the array because Hook is out of scope.
// Since it could potentially have been edited, remount the component.
should_reset = true;
} else {
custom_hook_in_scope.push(hook);
}
}
if should_reset || !custom_hook_in_scope.is_empty() {
args.push(should_reset.as_arg());
}
if !custom_hook_in_scope.is_empty() {
let elems = custom_hook_in_scope
.into_iter()
.map(|hook| {
Some(
match hook {
HookCall::Ident(ident) => Expr::from(ident),
HookCall::Member(obj, prop) => MemberExpr {
span: DUMMY_SP,
obj: Box::new(obj),
prop: MemberProp::Ident(prop),
}
.into(),
}
.as_arg(),
)
})
.collect();
args.push(
Function {
is_generator: false,
is_async: false,
params: Vec::new(),
decorators: Vec::new(),
span: DUMMY_SP,
body: Some(BlockStmt {
span: DUMMY_SP,
stmts: vec![Stmt::Return(ReturnStmt {
span: DUMMY_SP,
arg: Some(Box::new(Expr::Array(ArrayLit {
span: DUMMY_SP,
elems,
}))),
})],
..Default::default()
}),
..Default::default()
}
.as_arg(),
);
}
CallExpr {
span: DUMMY_SP,
callee: handle.as_callee(),
args,
..Default::default()
}
.into()
}
fn gen_hook_register_stmt(&mut self, ident: Ident, sig: HookSig) {
self.ident.push(sig.handle.clone());
self.extra_stmt.push(
ExprStmt {
span: DUMMY_SP,
expr: Box::new(self.wrap_with_register(sig.handle, ident.into(), sig.hooks)),
}
.into(),
)
}
}
impl VisitMut for HookRegister<'_> {
noop_visit_mut_type!();
fn visit_mut_block_stmt(&mut self, b: &mut BlockStmt) {
let old_ident = self.ident.take();
let old_stmts = self.extra_stmt.take();
self.current_scope.push(b.ctxt);
let stmt_count = b.stmts.len();
let stmts = mem::replace(&mut b.stmts, Vec::with_capacity(stmt_count));
for mut stmt in stmts {
stmt.visit_mut_children_with(self);
b.stmts.push(stmt);
b.stmts.append(&mut self.extra_stmt);
}
if !self.ident.is_empty() {
b.stmts.insert(0, self.gen_hook_handle())
}
self.current_scope.pop();
self.ident = old_ident;
self.extra_stmt = old_stmts;
}
fn visit_mut_expr(&mut self, e: &mut Expr) {
e.visit_mut_children_with(self);
match e {
Expr::Fn(FnExpr { function: f, .. }) if f.body.is_some() => {
let sig = collect_hooks(&mut f.body.as_mut().unwrap().stmts, self.cm);
if let Some(HookSig { handle, hooks }) = sig {
self.ident.push(handle.clone());
*e = self.wrap_with_register(handle, e.take(), hooks);
}
}
Expr::Arrow(ArrowExpr { body, .. }) => {
let sig = collect_hooks_arrow(body, self.cm);
if let Some(HookSig { handle, hooks }) = sig {
self.ident.push(handle.clone());
*e = self.wrap_with_register(handle, e.take(), hooks);
}
}
_ => (),
}
}
fn visit_mut_var_decl(&mut self, n: &mut VarDecl) {
// we don't want visit_mut_expr to mess up with function name inference
// so intercept it here
for decl in n.decls.iter_mut() {
if let VarDeclarator {
// it doesn't quite make sense for other Pat to appear here
name: Pat::Ident(id),
init: Some(init),
..
} = decl
{
match init.as_mut() {
Expr::Fn(FnExpr { function: f, .. }) if f.body.is_some() => {
f.body.visit_mut_with(self);
if let Some(sig) =
collect_hooks(&mut f.body.as_mut().unwrap().stmts, self.cm)
{
self.gen_hook_register_stmt(Ident::from(&*id), sig);
}
}
Expr::Arrow(ArrowExpr { body, .. }) => {
body.visit_mut_with(self);
if let Some(sig) = collect_hooks_arrow(body, self.cm) {
self.gen_hook_register_stmt(Ident::from(&*id), sig);
}
}
_ => self.visit_mut_expr(init),
}
} else {
decl.visit_mut_children_with(self)
}
}
}
fn visit_mut_default_decl(&mut self, d: &mut DefaultDecl) {
d.visit_mut_children_with(self);
// only when expr has ident
match d {
DefaultDecl::Fn(FnExpr {
ident: Some(ident),
function: f,
}) if f.body.is_some() => {
if let Some(sig) = collect_hooks(&mut f.body.as_mut().unwrap().stmts, self.cm) {
self.gen_hook_register_stmt(ident.clone(), sig);
}
}
_ => {}
}
}
fn visit_mut_fn_decl(&mut self, f: &mut FnDecl) {
f.visit_mut_children_with(self);
if let Some(body) = &mut f.function.body {
if let Some(sig) = collect_hooks(&mut body.stmts, self.cm) {
self.gen_hook_register_stmt(f.ident.clone(), sig);
}
}
}
}
fn collect_hooks(stmts: &mut Vec<Stmt>, cm: &SourceMap) -> Option<HookSig> {
let mut hook = HookCollector {
state: Vec::new(),
cm,
};
stmts.visit_with(&mut hook);
if !hook.state.is_empty() {
let sig = HookSig::new(hook.state);
stmts.insert(0, make_call_stmt(sig.handle.clone()));
Some(sig)
} else {
None
}
}
fn collect_hooks_arrow(body: &mut BlockStmtOrExpr, cm: &SourceMap) -> Option<HookSig> {
match body {
BlockStmtOrExpr::BlockStmt(block) => collect_hooks(&mut block.stmts, cm),
BlockStmtOrExpr::Expr(expr) => {
let mut hook = HookCollector {
state: Vec::new(),
cm,
};
expr.visit_with(&mut hook);
if !hook.state.is_empty() {
let sig = HookSig::new(hook.state);
*body = BlockStmtOrExpr::BlockStmt(BlockStmt {
span: expr.span(),
stmts: vec![
make_call_stmt(sig.handle.clone()),
Stmt::Return(ReturnStmt {
span: expr.span(),
arg: Some(Box::new(expr.as_mut().take())),
}),
],
..Default::default()
});
Some(sig)
} else {
None
}
}
}
}
struct HookCollector<'a> {
state: Vec<Hook>,
cm: &'a SourceMap,
}
fn is_hook_like(s: &str) -> bool {
if let Some(s) = s.strip_prefix("use") {
s.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
} else {
false
}
}
impl HookCollector<'_> {
fn get_hook_from_call_expr(&self, expr: &CallExpr, lhs: Option<&Pat>) -> Option<Hook> {
let callee = if let Callee::Expr(callee) = &expr.callee {
Some(callee.as_ref())
} else {
None
}?;
let mut hook_call = None;
let ident = match callee {
Expr::Ident(ident) => {
hook_call = Some(HookCall::Ident(ident.clone()));
Some(&ident.sym)
}
// hook cannot be used in class, so we're fine without SuperProp
Expr::Member(MemberExpr {
obj,
prop: MemberProp::Ident(ident),
..
}) => {
hook_call = Some(HookCall::Member(*obj.clone(), ident.clone()));
Some(&ident.sym)
}
_ => None,
}?;
let name = if is_hook_like(ident) {
Some(ident)
} else {
None
}?;
let mut key = if let Some(name) = lhs {
self.cm.span_to_snippet(name.span()).unwrap_or_default()
} else {
String::new()
};
// Some built-in Hooks reset on edits to arguments.
if *name == "useState" && !expr.args.is_empty() {
// useState first argument is initial state.
let _ = write!(
key,
"({})",
self.cm
.span_to_snippet(expr.args[0].span())
.unwrap_or_default()
);
} else if name == "useReducer" && expr.args.len() > 1 {
// useReducer second argument is initial state.
let _ = write!(
key,
"({})",
self.cm
.span_to_snippet(expr.args[1].span())
.unwrap_or_default()
);
}
let callee = hook_call?;
Some(Hook { callee, key })
}
fn get_hook_from_expr(&self, expr: &Expr, lhs: Option<&Pat>) -> Option<Hook> {
if let Expr::Call(call) = expr {
self.get_hook_from_call_expr(call, lhs)
} else {
None
}
}
}
impl Visit for HookCollector<'_> {
noop_visit_type!();
fn visit_block_stmt_or_expr(&mut self, _: &BlockStmtOrExpr) {}
fn visit_block_stmt(&mut self, _: &BlockStmt) {}
fn visit_expr(&mut self, expr: &Expr) {
expr.visit_children_with(self);
if let Expr::Call(call) = expr {
if let Some(hook) = self.get_hook_from_call_expr(call, None) {
self.state.push(hook)
}
}
}
fn visit_stmt(&mut self, stmt: &Stmt) {
match stmt {
Stmt::Expr(ExprStmt { expr, .. }) => {
if let Some(hook) = self.get_hook_from_expr(expr, None) {
self.state.push(hook)
} else {
stmt.visit_children_with(self)
}
}
Stmt::Decl(Decl::Var(var_decl)) => {
for decl in &var_decl.decls {
if let Some(init) = &decl.init {
if let Some(hook) = self.get_hook_from_expr(init, Some(&decl.name)) {
self.state.push(hook)
} else {
stmt.visit_children_with(self)
}
} else {
stmt.visit_children_with(self)
}
}
}
Stmt::Return(ReturnStmt { arg: Some(arg), .. }) => {
if let Some(hook) = self.get_hook_from_expr(arg.as_ref(), None) {
self.state.push(hook)
} else {
stmt.visit_children_with(self)
}
}
_ => stmt.visit_children_with(self),
}
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/refresh/mod.rs | Rust | use rustc_hash::FxHashSet;
use swc_common::{
comments::Comments, sync::Lrc, util::take::Take, BytePos, Mark, SourceMap, SourceMapper, Span,
Spanned, SyntaxContext, DUMMY_SP,
};
use swc_ecma_ast::*;
use swc_ecma_utils::{private_ident, quote_ident, quote_str, ExprFactory};
use swc_ecma_visit::{visit_mut_pass, Visit, VisitMut, VisitMutWith};
use self::{
hook::HookRegister,
util::{collect_ident_in_jsx, is_body_arrow_fn, is_import_or_require, make_assign_stmt},
};
pub mod options;
use options::RefreshOptions;
mod hook;
mod util;
#[cfg(test)]
mod tests;
struct Hoc {
insert: bool,
reg: Vec<(Ident, Id)>,
hook: Option<HocHook>,
}
struct HocHook {
callee: Callee,
rest_arg: Vec<ExprOrSpread>,
}
enum Persist {
Hoc(Hoc),
Component(Ident),
None,
}
fn get_persistent_id(ident: &Ident) -> Persist {
if ident.sym.starts_with(|c: char| c.is_ascii_uppercase()) {
if cfg!(debug_assertions) && ident.ctxt == SyntaxContext::empty() {
panic!("`{}` should be resolved", ident)
}
Persist::Component(ident.clone())
} else {
Persist::None
}
}
/// `react-refresh/babel`
/// https://github.com/facebook/react/blob/main/packages/react-refresh/src/ReactFreshBabelPlugin.js
pub fn refresh<C: Comments>(
dev: bool,
options: Option<RefreshOptions>,
cm: Lrc<SourceMap>,
comments: Option<C>,
global_mark: Mark,
) -> impl Pass {
visit_mut_pass(Refresh {
enable: dev && options.is_some(),
cm,
comments,
should_reset: false,
options: options.unwrap_or_default(),
global_mark,
})
}
struct Refresh<C: Comments> {
enable: bool,
options: RefreshOptions,
cm: Lrc<SourceMap>,
should_reset: bool,
comments: Option<C>,
global_mark: Mark,
}
impl<C: Comments> Refresh<C> {
fn get_persistent_id_from_var_decl(
&self,
var_decl: &mut VarDecl,
used_in_jsx: &FxHashSet<Id>,
hook_reg: &mut HookRegister,
) -> Persist {
// We only handle the case when a single variable is declared
if let [VarDeclarator {
name: Pat::Ident(binding),
init: Some(init_expr),
..
}] = var_decl.decls.as_mut_slice()
{
if used_in_jsx.contains(&binding.to_id()) && !is_import_or_require(init_expr) {
match init_expr.as_ref() {
// TaggedTpl is for something like styled.div`...`
Expr::Arrow(_) | Expr::Fn(_) | Expr::TaggedTpl(_) | Expr::Call(_) => {
return Persist::Component(Ident::from(&*binding))
}
_ => (),
}
}
if let Persist::Component(persistent_id) = get_persistent_id(&Ident::from(&*binding)) {
return match init_expr.as_mut() {
Expr::Fn(_) => Persist::Component(persistent_id),
Expr::Arrow(ArrowExpr { body, .. }) => {
// Ignore complex function expressions like
// let Foo = () => () => {}
if is_body_arrow_fn(body) {
Persist::None
} else {
Persist::Component(persistent_id)
}
}
// Maybe a HOC.
Expr::Call(call_expr) => {
let res = self.get_persistent_id_from_possible_hoc(
call_expr,
vec![(private_ident!("_c"), persistent_id.to_id())],
hook_reg,
);
if let Persist::Hoc(Hoc {
insert,
reg,
hook: Some(hook),
}) = res
{
make_hook_reg(init_expr.as_mut(), hook);
Persist::Hoc(Hoc {
insert,
reg,
hook: None,
})
} else {
res
}
}
_ => Persist::None,
};
}
}
Persist::None
}
fn get_persistent_id_from_possible_hoc(
&self,
call_expr: &mut CallExpr,
mut reg: Vec<(Ident, Id)>,
hook_reg: &mut HookRegister,
) -> Persist {
let first_arg = match call_expr.args.as_mut_slice() {
[first, ..] => &mut first.expr,
_ => return Persist::None,
};
let callee = if let Callee::Expr(expr) = &call_expr.callee {
expr
} else {
return Persist::None;
};
let hoc_name = match callee.as_ref() {
Expr::Ident(fn_name) => fn_name.sym.to_string(),
// original react implement use `getSource` so we just follow them
Expr::Member(member) => self.cm.span_to_snippet(member.span).unwrap_or_default(),
_ => return Persist::None,
};
let reg_str = (
format!("{}${}", reg.last().unwrap().1 .0, &hoc_name).into(),
SyntaxContext::empty(),
);
match first_arg.as_mut() {
Expr::Call(expr) => {
let reg_ident = private_ident!("_c");
reg.push((reg_ident.clone(), reg_str));
if let Persist::Hoc(hoc) =
self.get_persistent_id_from_possible_hoc(expr, reg, hook_reg)
{
let mut first = first_arg.take();
if let Some(HocHook { callee, rest_arg }) = &hoc.hook {
let span = first.span();
let mut args = vec![first.as_arg()];
args.extend(rest_arg.clone());
first = CallExpr {
span,
callee: callee.clone(),
args,
..Default::default()
}
.into()
}
*first_arg = Box::new(make_assign_stmt(reg_ident, first));
Persist::Hoc(hoc)
} else {
Persist::None
}
}
Expr::Fn(_) | Expr::Arrow(_) => {
let reg_ident = private_ident!("_c");
let mut first = first_arg.take();
first.visit_mut_with(hook_reg);
let hook = if let Expr::Call(call) = first.as_ref() {
let res = Some(HocHook {
callee: call.callee.clone(),
rest_arg: call.args[1..].to_owned(),
});
*first_arg = Box::new(make_assign_stmt(reg_ident.clone(), first));
res
} else {
*first_arg = Box::new(make_assign_stmt(reg_ident.clone(), first));
None
};
reg.push((reg_ident, reg_str));
Persist::Hoc(Hoc {
reg,
insert: true,
hook,
})
}
// export default hoc(Foo)
// const X = hoc(Foo)
Expr::Ident(ident) => {
if let Persist::Component(_) = get_persistent_id(ident) {
Persist::Hoc(Hoc {
reg,
insert: true,
hook: None,
})
} else {
Persist::None
}
}
_ => Persist::None,
}
}
}
/// We let user do /* @refresh reset */ to reset state in the whole file.
impl<C> Visit for Refresh<C>
where
C: Comments,
{
fn visit_span(&mut self, n: &Span) {
if self.should_reset {
return;
}
let mut should_refresh = self.should_reset;
if let Some(comments) = &self.comments {
if !n.hi.is_dummy() {
comments.with_leading(n.hi - BytePos(1), |comments| {
if comments.iter().any(|c| c.text.contains("@refresh reset")) {
should_refresh = true
}
});
}
comments.with_leading(n.lo, |comments| {
if comments.iter().any(|c| c.text.contains("@refresh reset")) {
should_refresh = true
}
});
comments.with_trailing(n.lo, |comments| {
if comments.iter().any(|c| c.text.contains("@refresh reset")) {
should_refresh = true
}
});
}
self.should_reset = should_refresh;
}
}
// TODO: figure out if we can insert all registers at once
impl<C: Comments> VisitMut for Refresh<C> {
// Does anyone write react without esmodule?
// fn visit_mut_script(&mut self, _: &mut Script) {}
fn visit_mut_module(&mut self, n: &mut Module) {
if !self.enable {
return;
}
// to collect comments
self.visit_module(n);
self.visit_mut_module_items(&mut n.body);
}
fn visit_mut_module_items(&mut self, module_items: &mut Vec<ModuleItem>) {
let used_in_jsx = collect_ident_in_jsx(module_items);
let mut items = Vec::with_capacity(module_items.len());
let mut refresh_regs = Vec::<(Ident, Id)>::new();
let mut hook_visitor = HookRegister {
options: &self.options,
ident: Vec::new(),
extra_stmt: Vec::new(),
current_scope: vec![SyntaxContext::empty().apply_mark(self.global_mark)],
cm: &self.cm,
should_reset: self.should_reset,
};
for mut item in module_items.take() {
let persistent_id = match &mut item {
// function Foo() {}
ModuleItem::Stmt(Stmt::Decl(Decl::Fn(FnDecl { ident, .. }))) => {
get_persistent_id(ident)
}
// export function Foo() {}
ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
decl: Decl::Fn(FnDecl { ident, .. }),
..
})) => get_persistent_id(ident),
// export default function Foo() {}
ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {
decl:
DefaultDecl::Fn(FnExpr {
// We don't currently handle anonymous default exports.
ident: Some(ident),
..
}),
..
})) => get_persistent_id(ident),
// const Foo = () => {}
// export const Foo = () => {}
ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl)))
| ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
decl: Decl::Var(var_decl),
..
})) => {
self.get_persistent_id_from_var_decl(var_decl, &used_in_jsx, &mut hook_visitor)
}
// This code path handles nested cases like:
// export default memo(() => {})
// In those cases it is more plausible people will omit names
// so they're worth handling despite possible false positives.
ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(ExportDefaultExpr {
expr,
span,
})) => {
if let Expr::Call(call) = expr.as_mut() {
if let Persist::Hoc(Hoc { reg, hook, .. }) = self
.get_persistent_id_from_possible_hoc(
call,
vec![(
private_ident!("_c"),
("%default%".into(), SyntaxContext::empty()),
)],
&mut hook_visitor,
)
{
if let Some(hook) = hook {
make_hook_reg(expr.as_mut(), hook)
}
item = ExportDefaultExpr {
expr: Box::new(make_assign_stmt(reg[0].0.clone(), expr.take())),
span: *span,
}
.into();
Persist::Hoc(Hoc {
insert: false,
reg,
hook: None,
})
} else {
Persist::None
}
} else {
Persist::None
}
}
_ => Persist::None,
};
if let Persist::Hoc(_) = persistent_id {
// we need to make hook transform happens after component for
// HOC
items.push(item);
} else {
item.visit_mut_children_with(&mut hook_visitor);
items.push(item);
items.extend(
hook_visitor
.extra_stmt
.take()
.into_iter()
.map(ModuleItem::Stmt),
);
}
match persistent_id {
Persist::None => (),
Persist::Component(persistent_id) => {
let registration_handle = private_ident!("_c");
refresh_regs.push((registration_handle.clone(), persistent_id.to_id()));
items.push(
ExprStmt {
span: DUMMY_SP,
expr: Box::new(make_assign_stmt(
registration_handle,
persistent_id.into(),
)),
}
.into(),
);
}
Persist::Hoc(mut hoc) => {
hoc.reg = hoc.reg.into_iter().rev().collect();
if hoc.insert {
let (ident, name) = hoc.reg.last().unwrap();
items.push(
ExprStmt {
span: DUMMY_SP,
expr: Box::new(make_assign_stmt(
ident.clone(),
Ident::new(name.0.clone(), DUMMY_SP, name.1).into(),
)),
}
.into(),
)
}
refresh_regs.append(&mut hoc.reg);
}
}
}
if !hook_visitor.ident.is_empty() {
items.insert(0, hook_visitor.gen_hook_handle().into());
}
// Insert
// ```
// var _c, _c1;
// ```
if !refresh_regs.is_empty() {
items.push(
VarDecl {
span: DUMMY_SP,
kind: VarDeclKind::Var,
declare: false,
decls: refresh_regs
.iter()
.map(|(handle, _)| VarDeclarator {
span: DUMMY_SP,
name: handle.clone().into(),
init: None,
definite: false,
})
.collect(),
..Default::default()
}
.into(),
);
}
// Insert
// ```
// $RefreshReg$(_c, "Hello");
// $RefreshReg$(_c1, "Foo");
// ```
let refresh_reg = self.options.refresh_reg.as_str();
for (handle, persistent_id) in refresh_regs {
items.push(
ExprStmt {
span: DUMMY_SP,
expr: CallExpr {
callee: quote_ident!(refresh_reg).as_callee(),
args: vec![handle.as_arg(), quote_str!(persistent_id.0).as_arg()],
..Default::default()
}
.into(),
}
.into(),
);
}
*module_items = items
}
fn visit_mut_ts_module_decl(&mut self, _: &mut TsModuleDecl) {}
}
fn make_hook_reg(expr: &mut Expr, mut hook: HocHook) {
let span = expr.span();
let mut args = vec![expr.take().as_arg()];
args.append(&mut hook.rest_arg);
*expr = CallExpr {
span,
callee: hook.callee,
args,
..Default::default()
}
.into();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/refresh/options.rs | Rust | use serde::{Deserialize, Deserializer, Serialize};
use swc_atoms::{atom, Atom};
#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]
pub struct RefreshOptions {
#[serde(default = "default_refresh_reg")]
pub refresh_reg: Atom,
#[serde(default = "default_refresh_sig")]
pub refresh_sig: Atom,
#[serde(default = "default_emit_full_signatures")]
pub emit_full_signatures: bool,
}
fn default_refresh_reg() -> Atom {
atom!("$RefreshReg$")
}
fn default_refresh_sig() -> Atom {
atom!("$RefreshSig$")
}
fn default_emit_full_signatures() -> bool {
// Prefer to hash when we can
// This makes it deterministically compact, even if there's
// e.g. a useState initializer with some code inside.
false
}
impl Default for RefreshOptions {
fn default() -> Self {
RefreshOptions {
refresh_reg: default_refresh_reg(),
refresh_sig: default_refresh_sig(),
emit_full_signatures: default_emit_full_signatures(),
}
}
}
#[derive(Deserialize)]
#[serde(untagged)]
enum BoolOrRefresh {
Bool(bool),
Refresh(RefreshOptions),
}
pub fn deserialize_refresh<'de, D>(deserializer: D) -> Result<Option<RefreshOptions>, D::Error>
where
D: Deserializer<'de>,
{
match BoolOrRefresh::deserialize(deserializer)? {
BoolOrRefresh::Refresh(refresh) => Ok(Some(refresh)),
BoolOrRefresh::Bool(true) => Ok(Some(Default::default())),
BoolOrRefresh::Bool(false) => Ok(None),
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/refresh/tests.rs | Rust | use swc_ecma_transforms_base::resolver;
use swc_ecma_transforms_testing::{test, Tester};
use super::*;
use crate::jsx;
fn tr(t: &mut Tester) -> impl Pass {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
refresh(
true,
Some(RefreshOptions {
emit_full_signatures: true,
..Default::default()
}),
t.cm.clone(),
Some(t.comments.clone()),
top_level_mark,
),
)
}
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
normal_function,
r#"
function Hello() {
function handleClick() {}
return <h1 onClick={handleClick}>Hi</h1>;
}
function Bar() {
return <Hello />;
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
export_function,
r#"
export function Hello() {
function handleClick() {}
return <h1 onClick={handleClick}>Hi</h1>;
}
export default function Bar() {
return <Hello />;
}
function Baz() {
return <h1>OK</h1>;
}
const NotAComp = 'hi';
export { Baz, NotAComp };
export function sum() {}
export const Bad = 42;
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
export_named_arrow_function,
r#"
export const Hello = () => {
function handleClick() {}
return <h1 onClick={handleClick}>Hi</h1>;
};
export let Bar = (props) => <Hello />;
export default () => {
// This one should be ignored.
// You should name your components.
return <Hello />;
};
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
reassigned_function,
// TODO: in the future, we may *also* register the wrapped one.
r#"
function Hello() {
return <h1>Hi</h1>;
}
Hello = connect(Hello);
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
pascal_case_only,
r#"
function hello() {
return 2 * 2;
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
anonymous_function_expressions_declaration,
r#"
let Hello = function() {
function handleClick() {}
return <h1 onClick={handleClick}>Hi</h1>;
};
const Bar = function Baz() {
return <Hello />;
};
function sum() {}
let Baz = 10;
var Qux;
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
named_arrow_function_expressions_declaration,
r#"
let Hello = () => {
const handleClick = () => {};
return <h1 onClick={handleClick}>Hi</h1>;
}
const Bar = () => {
return <Hello />;
};
var Baz = () => <div />;
var sum = () => {};
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
ignore_hoc,
// TODO: we might want to handle HOCs at usage site, however.
// TODO: it would be nice if we could always avoid registering
r#"
let connect = () => {
function Comp() {
const handleClick = () => {};
return <h1 onClick={handleClick}>Hi</h1>;
}
return Comp;
};
function withRouter() {
return function Child() {
const handleClick = () => {};
return <h1 onClick={handleClick}>Hi</h1>;
}
};
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
ignore_complex_definition,
r#"
let A = foo ? () => {
return <h1>Hi</h1>;
} : null
const B = (function Foo() {
return <h1>Hi</h1>;
})();
let C = () => () => {
return <h1>Hi</h1>;
};
let D = bar && (() => {
return <h1>Hi</h1>;
});
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
ignore_unnamed_function_declarations,
r#"export default function() {}"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_likely_hoc_1,
r#"
const A = forwardRef(function() {
return <h1>Foo</h1>;
});
export const B = memo(React.forwardRef(() => {
return <h1>Foo</h1>;
}));
export default React.memo(forwardRef((props, ref) => {
return <h1>Foo</h1>;
}));
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_likely_hoc_2,
r#"
export default React.memo(forwardRef(function (props, ref) {
return <h1>Foo</h1>;
}));
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_likely_hoc_3,
r#"
export default React.memo(forwardRef(function Named(props, ref) {
return <h1>Foo</h1>;
}));
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_likely_hoc_4,
r#"
function Foo() {
return <div>123</div>
}
export default memo(Foo)
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
ignore_not_hoc,
r#"
const throttledAlert = throttle(function() {
alert('Hi');
});
const TooComplex = (function() { return hello })(() => {});
if (cond) {
const Foo = thing(() => {});
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_identifiers_used_in_jsx,
r#"
import A from './A';
import Store from './Store';
Store.subscribe();
const Header = styled.div`color: red`
const StyledFactory1 = styled('div')`color: hotpink`
const StyledFactory2 = styled('div')({ color: 'hotpink' })
const StyledFactory3 = styled(A)({ color: 'hotpink' })
const FunnyFactory = funny.factory``;
let Alias1 = A;
let Alias2 = A.Foo;
const Dict = {};
function Foo() {
return (
<div><A /><B /><StyledFactory1 /><StyledFactory2 /><StyledFactory3 /><Alias1 /><Alias2 /><Header /><Dict.X /></div>
);
}
const B = hoc(A);
// This is currently registered as a false positive:
const NotAComponent = wow(A);
// We could avoid it but it also doesn't hurt.
"#
);
// When in doubt, register variables that were used in JSX.
// Foo, Header, and B get registered.
// A doesn't get registered because it's not declared locally.
// Alias doesn't get registered because its definition is just an identifier.
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_identifiers_used_in_create_element,
r#"
import A from './A';
import Store from './Store';
Store.subscribe();
const Header = styled.div`color: red`
const StyledFactory1 = styled('div')`color: hotpink`
const StyledFactory2 = styled('div')({ color: 'hotpink' })
const StyledFactory3 = styled(A)({ color: 'hotpink' })
const FunnyFactory = funny.factory``;
let Alias1 = A;
let Alias2 = A.Foo;
const Dict = {};
function Foo() {
return [
React.createElement(A),
React.createElement(B),
React.createElement(StyledFactory1),
React.createElement(StyledFactory2),
React.createElement(StyledFactory3),
React.createElement(Alias1),
React.createElement(Alias2),
jsx(Header),
React.createElement(Dict.X),
];
}
React.createContext(Store);
const B = hoc(A);
// This is currently registered as a false positive:
const NotAComponent = wow(A);
// We could avoid it but it also doesn't hurt.
"#
);
test!(
ignore,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_identifiers_used_in_jsx_false_positive,
r#"
const A = foo() {}
const B = () => {
const A = () => null
return <A />
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_capitalized_identifiers_in_hoc,
r#"
function Foo() {
return <h1>Hi</h1>;
}
export default hoc(Foo);
export const A = hoc(Foo);
const B = hoc(Foo);
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_fn_with_hooks,
r#"
export default function App() {
const [foo, setFoo] = useState(0);
React.useEffect(() => {});
return <h1>{foo}</h1>;
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_fn_with_hooks_2,
r#"
export function Foo() {
const [foo, setFoo] = useState(0);
React.useEffect(() => {});
return <h1>{foo}</h1>;
}
function Bar() {
const [foo, setFoo] = useState(0);
React.useEffect(() => {});
return <h1>{foo}</h1>;
}
function baz() {
return (useState(), useState())
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_fn_expr_with_hooks,
r#"
export const A = React.memo(React.forwardRef((props, ref) => {
const [foo, setFoo] = useState(0);
React.useEffect(() => {});
return <h1 ref={ref}>{foo}</h1>;
}));
export const B = React.memo(React.forwardRef(function(props, ref) {
const [foo, setFoo] = useState(0);
React.useEffect(() => {});
return <h1 ref={ref}>{foo}</h1>;
}));
function hoc() {
return function Inner() {
const [foo, setFoo] = useState(0);
React.useEffect(() => {});
return <h1 ref={ref}>{foo}</h1>;
};
}
export let C = hoc();
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_fn_expr_with_hooks_2,
r#"
const A = function () {
const [foo, setFoo] = useState(0);
}, B = () => {
const [foo, setFoo] = useState(0);
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
register_implicit_arrow_returns,
r#"
export default () => useContext(X);
export const Foo = () => useContext(X);
module.exports = () => useContext(X);
const Bar = () => useContext(X);
const Baz = memo(() => useContext(X));
const Qux = () => (0, useContext(X));
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
hook_signatures_should_include_custom_hook,
r#"
function useFancyState() {
const [foo, setFoo] = React.useState(0);
useFancyEffect();
return foo;
}
const useFancyEffect = () => {
React.useEffect(() => {});
};
export default function App() {
const bar = useFancyState();
return <h1>{bar}</h1>;
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Typescript(::swc_ecma_parser::TsSyntax {
tsx: true,
..Default::default()
}),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
refresh(
true,
Some(RefreshOptions {
emit_full_signatures: true,
..Default::default()
}),
t.cm.clone(),
Some(t.comments.clone()),
top_level_mark,
),
jsx(
t.cm.clone(),
Some(t.comments.clone()),
Default::default(),
top_level_mark,
unresolved_mark,
),
)
},
include_hook_signature_in_commonjs,
r#"
import {useFancyState} from './hooks';
import useFoo from './foo'
export default function App() {
const bar = useFancyState();
const foo = useFoo()
return <h1>{bar}</h1>;
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
gen_valid_hook_signatures_for_exotic_hooks,
r#"
import FancyHook from 'fancy';
export default function App() {
function useFancyState() {
const [foo, setFoo] = React.useState(0);
useFancyEffect();
return foo;
}
const bar = useFancyState();
const baz = FancyHook.useThing();
React.useState();
useThePlatform();
return <h1>{bar}{baz}</h1>;
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Typescript(::swc_ecma_parser::TsSyntax {
tsx: true,
..Default::default()
}),
tr,
dont_consider_require_as_hoc,
r#"
const A = require('A');
const B = foo ? require('X') : require('Y');
const C = requireCond(gk, 'C');
const D = import('D');
import E = require('E');
export default function App() {
return (
<div>
<A />
<B />
<C />
<D />
<E />
</div>
);
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
should_refresh_when_has_comment,
r#"
export function Foo() {
const [foo, setFoo] = useState(0);
React.useEffect(() => {});
return <h1>{foo}</h1>;
}
function Bar() {
const [foo, setFoo] = useState(0);
React.useEffect(() => {
// @refresh reset
});
return <h1>{foo}</h1>;
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
dont_consider_iife_as_hoc,
r#"
while (item) {
(item => {
useFoo();
})(item);
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
|t| {
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
(
resolver(unresolved_mark, top_level_mark, false),
refresh(
true,
Some(RefreshOptions {
refresh_reg: "import_meta_refreshReg".into(),
refresh_sig: "import_meta_refreshSig".into(),
emit_full_signatures: true,
}),
t.cm.clone(),
Some(t.comments.clone()),
top_level_mark,
),
)
},
custom_identifier,
r#"
export default function Bar () {
useContext(X)
return <Foo />
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Typescript(::swc_ecma_parser::TsSyntax {
tsx: true,
..Default::default()
}),
tr,
issue_1865,
r#"
function useHooks() {
return useMemo(() => 1);
}
declare module 'x' {}
"#
);
test!(
module,
Default::default(),
tr,
next_001,
"
import dynamic from 'next/dynamic'
export const Comp = dynamic(() => import('../Content'), { ssr: false })
"
);
test!(
module,
Default::default(),
tr,
issue_2261,
"
export function App() {
console.log(useState())
return null;
}
"
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
nested_hook,
r#"
const a = (a) => {
const useE = useEffect;
return function useFoo() {
useE(() => console.log(a), []);
return useState(123);
};
}
"#
);
test!(
module,
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsSyntax {
jsx: true,
..Default::default()
}),
tr,
issue_6022,
r#"/* @refresh reset */
import { useState } from 'react';
function Counter() {
const [count, setCount] = useState(0);
return (
<button type="button" onClick={() => setCount(c => c + 1)}>{count}</button>
);
}
"#
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/src/refresh/util.rs | Rust | use rustc_hash::FxHashSet;
use swc_common::{Spanned, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_utils::ExprFactory;
use swc_ecma_visit::{noop_visit_type, Visit, VisitWith};
pub fn is_builtin_hook(name: &str) -> bool {
matches!(
name,
"useState"
| "useReducer"
| "useEffect"
| "useLayoutEffect"
| "useMemo"
| "useCallback"
| "useRef"
| "useContext"
| "useImperativeHandle"
| "useDebugValue"
)
}
pub fn is_body_arrow_fn(body: &BlockStmtOrExpr) -> bool {
if let BlockStmtOrExpr::Expr(body) = body {
body.is_arrow()
} else {
false
}
}
fn assert_hygiene(e: &Expr) {
if !cfg!(debug_assertions) {
return;
}
if let Expr::Ident(i) = e {
if i.ctxt == SyntaxContext::empty() {
panic!("`{}` should be resolved", i)
}
}
}
pub fn make_assign_stmt(handle: Ident, expr: Box<Expr>) -> Expr {
assert_hygiene(&expr);
AssignExpr {
span: expr.span(),
op: op!("="),
left: handle.into(),
right: expr,
}
.into()
}
pub fn make_call_stmt(handle: Ident) -> Stmt {
ExprStmt {
span: DUMMY_SP,
expr: Box::new(make_call_expr(handle)),
}
.into()
}
pub fn make_call_expr(handle: Ident) -> Expr {
CallExpr {
span: DUMMY_SP,
callee: handle.as_callee(),
args: Vec::new(),
..Default::default()
}
.into()
}
pub fn is_import_or_require(expr: &Expr) -> bool {
match expr {
Expr::Call(CallExpr {
callee: Callee::Expr(expr),
..
}) => {
if let Expr::Ident(ident) = expr.as_ref() {
ident.sym.contains("require")
} else {
false
}
}
Expr::Call(CallExpr {
callee: Callee::Import(_),
..
}) => true,
_ => false,
}
}
pub struct UsedInJsx(FxHashSet<Id>);
impl Visit for UsedInJsx {
noop_visit_type!();
fn visit_call_expr(&mut self, n: &CallExpr) {
n.visit_children_with(self);
if let Callee::Expr(expr) = &n.callee {
let ident = match expr.as_ref() {
Expr::Ident(ident) => ident.to_id(),
Expr::Member(MemberExpr {
prop: MemberProp::Ident(ident),
..
}) => (ident.sym.clone(), SyntaxContext::empty()),
_ => return,
};
if matches!(
ident.0.as_ref(),
"createElement" | "jsx" | "jsxDEV" | "jsxs"
) {
if let Some(ExprOrSpread { expr, .. }) = n.args.first() {
if let Expr::Ident(ident) = expr.as_ref() {
self.0.insert(ident.to_id());
}
}
}
}
}
fn visit_jsx_opening_element(&mut self, n: &JSXOpeningElement) {
if let JSXElementName::Ident(ident) = &n.name {
self.0.insert(ident.to_id());
}
}
}
pub fn collect_ident_in_jsx<V: VisitWith<UsedInJsx>>(item: &V) -> FxHashSet<Id> {
let mut visitor = UsedInJsx(FxHashSet::default());
item.visit_with(&mut visitor);
visitor.0
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/display_name/tests.rs/assignment_expression.js | JavaScript | foo = createReactClass({
displayName: "foo"
});
bar = React.createClass({
displayName: "bar"
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/display_name/tests.rs/assignment_expression_with_member.js | JavaScript | foo.x = createReactClass({
displayName: "x"
});
class A extends B {
render() {
super.x = React.createClass({
displayName: "x"
});
}
}
;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/display_name/tests.rs/nested.js | JavaScript | var foo = qux(createReactClass({
displayName: "foo"
}));
var bar = qux(React.createClass({
displayName: "bar"
}));
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/display_name/tests.rs/object_property.js | JavaScript | ({
foo: createReactClass({
displayName: "foo"
})
});
({
bar: React.createClass({
displayName: "bar"
})
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/display_name/tests.rs/variable_declarator.js | JavaScript | var foo = createReactClass({
displayName: "foo"
});
var bar = React.createClass({
displayName: "bar"
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/issue_229.js | JavaScript | const a = /*#__PURE__*/ React.createElement(React.Fragment, null, "test");
const b = /*#__PURE__*/ React.createElement("div", null, "test");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/issue_351.js | JavaScript | import React from 'react';
/*#__PURE__*/ React.createElement("div", null);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/issue_481.js | JavaScript | /*#__PURE__*/ React.createElement("span", null, " ", foo);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/issue_4956.js | JavaScript | /*#__PURE__*/ React.createElement("div", {
title: "\u2028"
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/issue_517.js | JavaScript | import React from 'react';
/*#__PURE__*/ React.createElement("div", {
style: "white-space: pre"
}, "Hello World");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/issue_542.js | JavaScript | let page = /*#__PURE__*/ React.createElement("p", null, "Click ", /*#__PURE__*/ React.createElement("em", null, "New melody"), " listen to a randomly generated melody");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/react_add_appropriate_newlines.js | JavaScript | /*#__PURE__*/ React.createElement(Component, {
...props,
sound: "moo"
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/react_arrow_functions.js | JavaScript | var foo = function() {
var _this = this;
return function() {
return /*#__PURE__*/ React.createElement(_this, null);
};
};
var bar = function() {
var _this = this;
return function() {
return /*#__PURE__*/ React.createElement(_this.foo, null);
};
};
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/react_attribute_html_entity_quote.js | JavaScript | /*#__PURE__*/ React.createElement(Component, {
text: 'Hello "World"'
});
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/react_concatenates_adjacent_string_literals.js | JavaScript | var x = /*#__PURE__*/ React.createElement("div", null, "foo", "bar", "baz", /*#__PURE__*/ React.createElement("div", null, "buz bang"), "qux", null, "quack");
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_react/tests/__swc_snapshots__/src/jsx/tests.rs/react_display_name_assignment_expression.js | JavaScript | var Component;
Component = React.createClass({
render: function render() {
return null;
},
displayName: "Component"
});
| 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.