Inconsistent slice/splice caching for splats and ranges

[jed]

Seeing that

(args...) ->
  args[1..2] = null

currently yields

var __slice = Array.prototype.slice;
(function() {
  var args;
  args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
  return ([].splice.apply(args, [1, 2].concat(null)), null);
});

is there any reason that slice is cached from Array.prototype, but not splice is used from a new array instance?

[TrevorBurnham]

Agreed, that is inconsistent. splice should be made to have the same behavior as slice.

[michaelficarra]

Eh, we should rethink both of them. It may be better to pull slice from [] instead of looking up a long scope chain. Like what we did for undefined. Consistency would be best, so it is probably wrong the way it is now.

[jashkenas]

It would be a great JSPerf to test the performance of [].splice/splice versus a cached function lookup.

[jed]

Like this?

[michaelficarra]

Eh, that's an alright test, but it doesn't consider longer scope chain lookups. Those caches are on the same scope object as their reference which should make for a very fast lookup.

[jed]

Hrm, I don't think there's an easy way in jsperf to control scope like that.

[].slice is consistently slow though.
http://jsperf.com/array-prototype-slice-call-vs-slice-call/7
My guess is Array.prototype.slice is fast because modern JS compilers would recognize that it's pointing to a statically stored object.
I would guess that _slice and slice are fast because they(the compilers) also notice the same thing.
[].slice is slow, I assume because it has to also create a new instance of an array and allocate memory for it.
But I would use Array.prototype.slice, seems consistent enough.
But I don't know if there is any way to know if the JS engines are optimizing away the functions.

[GeoffreyBooth]

Since #4526 this compiles to:

var splice = [].splice;

(function(...args) {
  return (splice.apply(args, [1, 2].concat(null)), null);
});

which is consistent with slice. It would still be a great test to compare the performance of [].splice versus the cached reference versus Array.prototype.splice, but that can be another issue.