**Description:**
The algorithm here is directly copied from terser, I don't if it's correct or can be improved, but it does fix the issue.
**Related issue:**
- Closes#7749
**Description:**
This issue is more severe than I originally thought. It raises not in
array indexing, but in function calls and property mutation. We should
treat all function arguments as potentially be property mutated,
otherwise following example
```js
class A {
a = 1
toString() {
return this.a
}
}
const a = new A()
function foo(x) {
x.a++
}
const b = a + 1
foo(a)
console.log(b)
```
would be error(It should log 2, but logs 3 after compress).
As the result, massive regressions is unavoidable, since some of these
optimizations may indeed cause error. Part of them can be mitigated with
following optimization -- allow inline of ident even if its original
value is mutated. Consider
```js
export function foo(x) {
const y = x
x.a = 1
y.b = 2
}
```
If x is a primitive value, all mutations to its properties are ignored;
if x is a object, then y refers to the same object no matter what
mutation is performed.
And there's still room for more, currently following code
```js
export function foo(x) {
const y = Math.floor(x);
g(y);
}
```
But I'd rather do it in a separate PR.
**Related issue:**
- Closes#7402.
**Description:**
This PR improves the alias analyzer by distinguishing call and reference, thus reducing the number of identifiers.
---
Co-authored-by: Justin Ridgewell <justin@ridgewell.name>
**Description:**
As our minifier is two-pass by default, this is enough.
At the first pass, we inline all numeric literals using sequential inliner, and minifier can then inline constants correctly in the second pass.
**Description:**
As we are not using the return value of the function, we can call `ignore_return_value` on the argument of the return statements of IIFE.
**Description:**
We had two passes for joining variables. This PR removes one in the full optimizer, which is wrong.
**Related issue:**
- Closes https://github.com/swc-project/swc/issues/5989.
