oxc-minify: clarify "Core Assumptions" like "No Monkey-Patching Built-ins"

[Fd929c2CE5fA]

https://github.com/oxc-project/oxc/blob/main/crates/oxc_minifier/docs/ASSUMPTIONS.md#core-assumptions

I'm sorry, but I don't understand what "Core Assumptions" means here. Does it mean that if I violate the assumption, incorrect minified code will be generated or what?

When I tried to minify this code I didn't see any exception:

// The minifier assumes this never happens:
Array.prototype.push = function() {
  console.log('hijacked!');
};
Object.defineProperty(Number.prototype, 'toString', { value: () => 'hijacked!' });
let array = [];
array.push("a");
console.log(array);
let n = 123;
console.log(n.toString());

Array.prototype.push=function(){console.log(`hijacked!`)},Object.defineProperty(Number.prototype,`toString`,{value:()=>`hijacked!`});let array=[];array.push(`a`),console.log(array);let n=123;console.log(n.toString());

Please help me better understand these "Core Assumptions", preferably with some unexpected examples, thank you.

[nrayburn-tech]

If you patch the Array push method (or any other standard methods/classes/etc.), then it will not be taken into account when the minifier runs. The minifier assumes that the standard functions operate in the standard way.

This below is very unlikely a real example, but it's simple so it communicates the problem well.
This source code

Array.prototype.push = function() {
  console.log('hijacked!');
};
const array = [];
array.push(1);
array.push(2);

Could be minified to something like the below.

Array.prototype.push = function() {
  console.log('hijacked!');
};
const array = [1, 2];

If you run the original code and the possible minified output, you'll see that the behavior is different. The first creates an empty array and logs two statements. The second provides you an array with 2 elements and does not log anything.

[nrayburn-tech]

I’m not sure who owns the minifier, but maybe @Boshen or @sapphi-red can share what they think here.

[sapphi-red]

I guess this assumption does not matter for the case of user scripts. Oxc minifier would assume that the input code does not rely on the overridden function. But for your case, the website code (which is not fed to the minifier) relies on the overridden function. i.e. it doesn't matter that the input code cannot observe the overridden behavior as long as the website code can observe it.

[Fd929c2CE5fA]

Thanks.

What I mean is that user scripts often require hook/overridden functions such as xhr or fetch etc. If we use oxc minify the code of these user scripts, will it possibly produce unexpected results? These hooks are usually for website scripts.

Oxc minifier would assume that the input code does not rely on the overridden function.

But will it cause problems if the script itself both overridden and depends on the patch? For example, I modified Array.prototype.push and also other code relied on this patch, will it cause problems after minify?

It seems like there's still room for confusion here, so "clarification" does make sense.

[sapphi-red]

I don't think it'll produce unexpected results because you'd not hook/override the functions for the code you own.

[Fd929c2CE5fA]

Yes, usually not. Thank you for your answer.