This PR contains:

• bugfix
• feature
• refactor
• documentation
• other

Are tests included?

• yes (bugfixes and features will not be merged without tests)
• no

Breaking Changes?

• yes (breaking changes will not be merged unless absolutely necessary)
• no

List any relevant issue numbers:
Resolves #4498
Resolves #4503
Resolves #4504
Resolves #4505
Resolves #4506
Resolves #4507

Description

This replaces the previous PR #4498 which has been rolled back. In the previous implementation, I had a hard time finding a way to make the feature "non-optimized by default" which meant an unprecedented amount of different bugs crept in. As it was feeling increasingly like playing whack-a-mole, I decided to revisit the general assumptions and greatly reduced the scope of the feature.
Now, parameter default tree-shaking will only be applied to top-level functions and IIFEs as in those cases, we can be fairly certain we can either track every possible call of a function or know when it is not possible.
In the previous implementation, tree-shaking was also possible for objects and static class methods, but I found there were sneaky bugs because here it is possible to call a function via this, or worse, via super, and those entirely depend on call context.

Still, all examples of the previous PR still work, which is why I will copy them here:

This allows tree-shaking for unnecessary default parameters in functions. This includes arrow functions but does not include nested defaults in destructuring patterns REPL

// input
const foo = (a = 'removed', { b = 'unused but included' } = 'removed') =>
  console.log(a,b);
foo('a', 'b');

// output
const foo = (a, { b = 'unused but included' }) =>
  console.log(a,b);
foo('a', 'b');

While the feature may sound simple at first glance, it was actually quite complex. The main problem is that JavaScript does not make a difference between not passing a parameter to a function and passing the value undefined: In both cases, the default value will be used.

Therefore, there are quite some subtleties involved which in the end I resolved by extending the mechanism I created for omitting unneeded parameters. This mechanism was removing arguments from function calls if the corresponding parameter was unused. Now, it will also see if parameter defaults need to be included. Care was taken to ensure no side effects are omitted REPL

// input
const foo = (a = 'removed because unused') => effect();
foo();

const bar = (a = effect('included because triggered')) => {};
// It does not make a difference if you pass nothing or undefined
bar(undefined);

const baz = (a = effect('removed')) => {};
baz('value');

// output
const foo = (a) => effect();
foo();

const bar = (a = effect('included because triggered')) => {};
// It does not make a difference if you pass nothing or undefined
bar();

const baz = (a) => {};
baz();

It is very important to track the instance where we "lose track" of how a function is used, e.g. because it is exported, passed to an unknown function etc. In those cases, all necessary defaults are included REPL

// input
export const foo = (a = 'included') => console.log(a);

// output
const foo = (a = 'included') => console.log(a);

export { foo };