I'm working on a compile to JS language and when tinkering with the emitter I found some strange performance difference A tuple type in the language is emitted as an JS array and a tuple type constructor is emitted as a function that returns it arguments as an JS array.
I tried these three outputs and discovered unexpectedly big performance differences. The only differences is how the tuple constructors are emitted, and the time is how long it taks for the compiler to build itself.
(...members) => members: ~3.6 secondsfunction () {return Array.prototype.slice.call(arguments)}~4.6 secondsfunction () {return Array.from(arguments)}~5.5 seconds
This is no way a scientific measurement but the time difference seems pretty big for such a small change in the compiler.
I don't know how many times the above functions gets called during the build but the rest of the code is a parser, a type checker and an emitter. There are multiple passes over the AST and it's not like the rest of the code is optimised. Even if there are big differences in a micro benchmark I would not expect this big difference on the total time.
@Pajn It's probably because the latter 2 rely on a function call, which is generally less performant than a language native.
Array.fromis just fairly expensive (it does a bunch of checks and coercion/transformation).