Commit graph

178 commits

Author SHA1 Message Date
Boshen
78f135d686 refactor(ast)!: remove ReferenceFlag from IdentifierReference (#5077)
closes #4512
2024-08-22 14:30:50 +00:00
IWANABETHATGUY
2b21be31ff feat(oxc_minifier): define plugin with postfix wildcard (#4979)
1. support `import.meta.env.*` in `ReplaceGlobalDefine`
2024-08-21 13:27:09 +00:00
overlookmotel
c4c08a7433 refactor(ast)!: rename IdentifierReference::reference_flags field (#5024)
Part of #4991.
2024-08-21 00:19:57 +00:00
overlookmotel
d262a58eb5 refactor(syntax)!: rename ReferenceFlag to ReferenceFlags (#5023)
Part of #4991.
2024-08-21 00:19:56 +00:00
Boshen
b4407c4e9a
refactor(oxc,mangler): oxc crate add mangler; mangler use options API 2024-08-20 22:58:59 +08:00
IWANABETHATGUY
0f64d106a0 refactor(minifier): remove duplicated helper move_out_expression (#5007) 2024-08-20 14:00:33 +00:00
Boshen
46cb1c1b7b fix(minifier): handle Object.definedPropert(exports for @babel/types/lib/index.js (#4933)
Discoverd in `monitor-oxc`

```javascript
Object.keys(_index6).forEach(function(key) {
	if (key === "default" || key === "__esModule") return;
	if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
	if (key in exports && exports[key] === _index6[key]) return;
	Object.defineProperty(exports, key, {
		enumerable: true,
		get: function() {
			return _index6[key];
		}
	});
});
```

🙃
2024-08-16 06:48:15 +00:00
Boshen
81fd6379e8 fix(minifier): do not fold 0 && (module.exports = {}) for cjs-module-lexer (#4878) 2024-08-13 12:54:59 +00:00
Boshen
879a271d47 fix(minifier): do not join require calls for cjs-module-lexer (#4875) 2024-08-13 12:21:37 +00:00
Boshen
fae8a62a62 fix(minifier): temporarily bail constant folding for tagged template (#4842)
closes #4341
2024-08-12 07:38:25 +00:00
overlookmotel
504ac0b178 perf(minifier): InjectGlobalVariables only add to replaced_dot_defines once for each (#4803)
`InjectGlobalVariables` minifier plugin was previously adding an entry to `replaced_dot_defines` each time it made a replacement, resulting in many duplicate entries if a single dot define gets replaced multiple times. Only add once for each dot define.
2024-08-10 13:46:15 +00:00
overlookmotel
35f27420b9 perf(minifier): avoid repeated Atom creation in InjectGlobalVariables (#4802)
Re-use `Atom`s in `InjectGlobalVariables` minifier plugin.

Instead of allocating a new `Atom` on every replacement, create `Atom` lazily when making first replacement, and cache it.

As discussed in: https://github.com/oxc-project/oxc/pull/4759#discussion_r1711669464
2024-08-10 13:46:14 +00:00
Boshen
c51929558d feat(minifier): add InjectGlobalVariables plugin (@rollup/plugin-inject) (#4759) 2024-08-10 01:12:31 +00:00
Boshen
fbfd852cf8 refactor(minifier): add NodeUtil trait for accessing symbols on ast nodes (#4734) 2024-08-08 02:48:25 +00:00
Boshen
e0832f8e18 refactor(minifier): use oxc_traverse for AST passes (#4725) 2024-08-07 13:26:29 +00:00
Boshen
17602db6de
refactor(minifier): move tests and files around 2024-08-07 20:01:55 +08:00
Boshen
94d3c31933 fix(minifier): avoid removing function declaration from KeepVar (#4722) 2024-08-07 05:09:32 +00:00
Boshen
bf43148f1e
fix(minifier): do not remove_syntax in dead_code_elimination 2024-08-06 16:34:04 +08:00
Boshen
bf48c7f02a fix(minifier): fix keep_var keeping vars from arrow functions (#4680) 2024-08-06 07:04:25 +00:00
Boshen
451ac4d0e3
chore: s/elimintation/elimination/ 2024-08-06 14:18:44 +08:00
Boshen
9be29af9d4 fix(minifier): temporarily fix shadowed undefined variable (#4678) 2024-08-06 04:58:39 +00:00
Boshen
0f5e982d19 perf(minifier): only visit arrow expression after dropping console.log (#4677) 2024-08-06 04:20:41 +00:00
Boshen
e8b662a314 fix(minifier): various fixes to pass minifier conformance (#4667) 2024-08-05 16:31:19 +00:00
camc314
229a0e9c45 feat(minifier): implement dot define for member expressions (#3959)
adds the ability to transform

`process.env.NODE_ENV`

into

`"development"`

when that config is passed in
2024-08-05 12:04:13 +00:00
Boshen
e78cba6464 refactor(minifier): ast passes infrastructure (#4625)
After studying google closure compiler, I'm leaning towards a multi-ast-pass infrastructure for the minifier.

This is one of the few places where we are going to trade maintainability over performance, given the goal of the minifier is compression size not performance.

All of the terminologies and separation of concerns are aligned with google closure compiler.

Infrastructure of `terser` and `esbuild` are not suitable for us to study nor pursuit. Their code are so tightly coupled - I failed to comprehend any of them every time I try to walk through a piece of optmization. Google closure compiler despite being written in Java, it's actually the most readable minifier out there.

To improve performance between ast passes, I envision a change detection system over a portion of the code.

The benchmark will demonstrate the performance regression of running 5 ast passes instead of 2.

To complete this PR, I need to figure out "fix-point" and order of these ast passes.
2024-08-04 11:58:39 +00:00
Boshen
e33ec18d78 feat(minifier): compress typeof foo == "undefined" into typeof foo > "u" (#4412)
```
> monitor-oxc@ test /home/runner/work/monitor-oxc/monitor-oxc
> node src/main.test.mjs

/home/runner/work/monitor-oxc/monitor-oxc/node_modules/.pnpm/react-dom@18.3.1_react@18.3.1/node_modules/react-dom/cjs/react-dom.development.js:2375
		if (void 0 === __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
		^

ReferenceError: __REACT_DEVTOOLS_GLOBAL_HOOK__ is not defined
    at injectInternals (/home/runner/work/monitor-oxc/monitor-oxc/node_modules/.pnpm/react-dom@18.3.1_react@18.3.1/node_modules/react-dom/cjs/react-dom.development.js:2375:3)
```
2024-07-22 12:44:33 +00:00
Boshen
267f7c4398
fix(minifier): skip Object.defineProperty(exports, ...) for cjs-module-lexer (#4409)
```
> monitor-oxc@ test /home/runner/work/monitor-oxc/monitor-oxc
> node src/main.test.mjs

file:///home/runner/work/monitor-oxc/monitor-oxc/node_modules/.pnpm/inquirer@[10](https://github.com/oxc-project/monitor-oxc/actions/runs/10038139357/job/27739464680#step:8:11).0.1/node_modules/inquirer/dist/esm/ui/prompt.mjs:2
import { defer, EMPTY, from, of, concatMap, filter, reduce, isObservable, lastValueFrom } from "rxjs";
                ^^^^^
SyntaxError: Named export 'EMPTY' not found. The requested module 'rxjs' is a CommonJS module, which may not support all module.exports as named exports.
CommonJS modules can always be imported via the default export, for example using:

import pkg from 'rxjs';
const { defer, EMPTY, from, of, concatMap, filter, reduce, isObservable, lastValueFrom } = pkg;

    at ModuleJob._instantiate (node:internal/modules/esm/module_job:134:21)
    at async ModuleJob.run (node:internal/modules/esm/module_job:217:5)
    at async ModuleLoader.import (node:internal/modules/esm/loader:316:24)
    at async asyncRunEntryPointWithESMLoader (node:internal/modules/run_main:[12](https://github.com/oxc-project/monitor-oxc/actions/runs/10038139357/job/27739464680#step:8:13)3:5)

Node.js v20.15.1
```

Export is undefined when `enumerable` is "!0".
See `https://github.com/nodejs/cjs-module-lexer/issues/64`
2024-07-22 20:32:15 +08:00
Boshen
0deb027e6b
feat(minfier): dce if (xxx) else if (false) { REMOVE } (#4407) 2024-07-22 19:57:35 +08:00
Boshen
5d17675cde feat(mangler): add debug mode (#4314)
closes #4303
2024-07-17 04:59:23 +00:00
overlookmotel
2c7bb9f6c8 refactor(ast): pass final ScopeFlags into visit_function (#4283)
We have a strange workaround for `visit_function` where we pass in `ScopeFlags`, to support creating the scope inside `Function`, but setting different flags for `MethodDefinition`s.

Previously `visit_function` took `Option<ScopeFlags>` and then did `flags.unwrap_or(ScopeFlags::empty()) | ScopeFlags::Function` to it. Personally, I found this confusing. When I was looking at `MethodDefinition`, I was wondering "It's a function, why doesn't it set Function flag too?"

This changes makes it more explicit and clear what `ScopeFlags` everything has.
2024-07-16 07:22:07 +00:00
underfin
f144082a60
fix(minifier): RemoveDeadCode should visit nested expression (#4268) 2024-07-15 19:37:12 +08:00
Boshen
e167ef79c6 fix(codegen): print parenthesis properly (#4245)
`TSParenthesizedType` handles parenthesis in ts types.

It should be considered a bug if parenthesis is not printed correctly after this PR.
2024-07-14 04:13:10 +00:00
Boshen
e3e663bae4 feat(mangler): initialize crate and integrate into minifier (#4197) 2024-07-11 10:35:13 +00:00
Boshen
c8184723f4 feat(minifier): dce conditional expression && or || (#4190) 2024-07-11 04:40:23 +00:00
Boshen
54cd04aead feat(minifier): implement dce with var hoisting (#4160) 2024-07-10 11:03:21 +00:00
Boshen
44a894a2f9 feat(minifier): implement return statement dce (#4155)
This isn't complete, I need to figure out `var` hoisting 🙃
2024-07-10 11:03:14 +00:00
rzvxa
b936162093 refactor(ast/ast_builder)!: shorter allocator utility method names. (#4122)
This PR serves two purposes, First off it would lower the amount of characters we have to type in for a simple operation such as wrapping an expression in a vector. Secondly, it would follow the generated names more closely since nowhere else in the builder we do have `new_xxx`, We always say `xxx` since a builder always constructs something.

```
new_vec -> vec
new_vec_single -> vec1*
new_vec_from_iter -> vec_from_iter
new_vec_with_capacity -> vec_with_capacity
new_str -> str
new_atom -> atom
```

`*` This one is the main motivation behind this PR, It saves 10 characters!
2024-07-09 12:16:38 +00:00
Boshen
c6c16a5fc9
feat(minifier): dce all conditional expressions (#4135) 2024-07-09 18:28:33 +08:00
rzvxa
d347aedfda feat(ast)!: generate ast_builder.rs. (#3890)
### Every structure has 2 builder methods:

1. `xxx` e.g. `block_statement`
```rust
    #[inline]
    pub fn block_statement(self, span: Span, body: Vec<'a, Statement<'a>>) -> BlockStatement<'a> {
        BlockStatement { span, body, scope_id: Default::default() }
    }
```
2. `alloc_xxx` e.g. `alloc_block_statement`
```rust
    #[inline]
    pub fn alloc_block_statement(
        self,
        span: Span,
        body: Vec<'a, Statement<'a>>,
    ) -> Box<'a, BlockStatement<'a>> {
        self.block_statement(span, body).into_in(self.allocator)
    }
```

### We generate 3 types of methods for enums:

1. `yyy_xxx` e.g. `statement_block`
```rust
    #[inline]
    pub fn statement_block(self, span: Span, body: Vec<'a, Statement<'a>>) -> Statement<'a> {
        Statement::BlockStatement(self.alloc(self.block_statement(span, body)))
    }
```
2. `yyy_from_xxx` e.g. `statement_from_block`
```rust
    #[inline]
    pub fn statement_from_block<T>(self, inner: T) -> Statement<'a>
    where
        T: IntoIn<'a, Box<'a, BlockStatement<'a>>>,
    {
        Statement::BlockStatement(inner.into_in(self.allocator))
    }
```
3. `yyy_xxx` where `xxx` is inherited e.g. `statement_declaration`
```rust
    #[inline]
    pub fn statement_declaration(self, inner: Declaration<'a>) -> Statement<'a> {
        Statement::from(inner)
    }
```

------------

### Generic parameters:

We no longer accept `Box<'a, ADT>`, `Atom` or `&'a str`, Instead we use `IntoIn<'a, Box<'a, ADT>>`, `IntoIn<'a, Atom<'a>>` and `IntoIn<'a, &'a str>` respectively.
It allows us to rewrite things like this:
```rust
let ident = IdentifierReference::new(SPAN, Atom::from("require"));
let number_literal_expr = self.ast.expression_numeric_literal(
    right_expr.span(),
    num,
    raw,
    self.ast.new_str(num.to_string().as_str()),
    NumberBase::Decimal,
);
```
As this:
```rust
let ident = IdentifierReference::new(SPAN, "require");
let number_literal_expr = self.ast.expression_numeric_literal(
    right_expr.span(),
    num,
    raw,
    num.to_string(),
    NumberBase::Decimal,
);
```
2024-07-09 00:57:26 +00:00
Boshen
719fb9672b
fix(minifier): omit dce undefined which can be a shadowed variable (#4073)
```
 // Shadowed `undefined` as a variable should not be erased.
    test(
        "function foo(undefined) { if (!undefined) { } }",
        "function foo(undefined){if(!undefined){}}",
    );
```

I'm not using the cheap `ident.reference_id.get().is_some()` here yet
because I don't know what I'm doing - how should minifier consume
`Semantic`?
2024-07-07 01:25:54 +08:00
Boshen
0da9dfbf09
feat(minifier): add constant folding to remove dead code (#4058) 2024-07-05 15:44:01 +08:00
Boshen
edb557c02b
refactor(minifier): add a folder struct for constant folding (#4057) 2024-07-05 15:11:08 +08:00
Boshen
aaac2d8775
fix(codegen): preserve parentheses from AST instead calculating from operator precedence (#4055)
…operator precedence

Calculating from operator precedence is currently unsafe and will result
incorrect semantics.
2024-07-05 14:01:17 +08:00
rzvxa
cd1e9bde7f improvement(ast): generate visit_mut.rs. (#4007) 2024-07-02 10:18:51 +00:00
Boshen
54c653ebd4 Revert "perf(semantic): use Atom<'a> for References" (#3974)
Reverts oxc-project/oxc#3972

@DonIsaac As it turns out we can't have lifetimes on these structures because semantic data is exposed to downstream users to use freely, detached from the ast and allocator.
2024-06-29 15:55:04 +00:00
Don Isaac
1eac3d244d
perf(semantic): use Atom<'a> for References (#3972)
Relates to [this
issue](https://github.com/oxc-project/backlog/issues/31) on the backlog.
2024-06-29 23:23:36 +08:00
camc314
77a4a0b77c feat(minifier) minify conditional expressions (#3907) 2024-06-26 05:06:53 +00:00
rzvxa
6796891e2e fix(ast)!: rename all instances of BigintLiteral to BigIntLiteral. (#3898)
Notice the casing! Just for the sake of consistency.
2024-06-25 14:39:42 +00:00
Boshen
dd540c8f0f feat(minifier): add skeleton for ReplaceGlobalDefines ast pass (#3803) 2024-06-21 13:53:59 +00:00
Boshen
f3c3970131 feat(minifier): add skeleton for RemoveDeadCode ast pass (#3802) 2024-06-21 07:18:14 +00:00