Babel loose mode is unsafe with array spread operator

[TrySound]

Bug Report

I just went though two bugs with array spread operator.

Spread of array constructor call

// input
[...Array(100)] // array of 100 undefined values
// output
Array(100).concat() // array of 100 empty values

Spread of string

// input
[...'abc'] // array of chars
// output
'abc'.concat() // "abc' string

Expected behavior/code
I think this loose mode is too loose and could be slightly improved with small helpers. This things are the only problems I had with loose mode in a year.

Babel Configuration (.babelrc, package.json, cli command)

{
  "presets": [["env", { "loose": true }]]
}

Environment

• Babel version(s): v7.0.0-beta.34

Possible Solution
Make loose mode for spread operator slightly stricter.

[babel-bot]

Hey @TrySound! We really appreciate you taking the time to report an issue. The collaborators
on this project attempt to help as many people as possible, but we're a limited number of volunteers,
so it's possible this won't be addressed swiftly.

If you need any help, or just have general Babel or JavaScript questions, we have a vibrant Slack
community that typically always has someone willing to help. You can sign-up here
for an invite.

[Andarist]

Well, this is a cost of using loose mode. It's not always spec-compliant and such cases might bite you. I don't think holey arrays are popular enough to warrant introducing toConsumableArray in the loose mode.

Maybe we could try to track if array might be holey and use this helper IF we know that it is - it would be limited only to the simplest situations though - analyzing runtime values with babel is not easy.

We could similarly special case string literals and convert them to 'abc'.split('') - but that would also only cover simplest situations.

[nicolo-ribaudo]

Loose mode assumes that your code behaves "in the most obvious way": Babel assumes that you are only using array spread with "normal" (e.g. not holey) arrays.

[kasperpeulen]

@nicolo-ribaudo

Loose mode assumes thematic your code behaves "in the most obvious way": Babel assumes that you are only using array spread with "normal" (e.g. not holey) arrays.

Spread was meant for all Iterable's, not only Array's. It should work with String, Set, Map, Generator etc.

export const locationChange = ({ pathname, search }) => ({
  type: LOCATION_CHANGE,
  mutation: {
    pathname,
    search,
    params:  new URLSearchParams(search)
        |> map(([key, value]) => ({ [key]: value }))
        // Array.from is needed because we use babel in loose mode
        |> it => Object.assign({}, ...Array.from(it)),
  },
});

Here Array.from is needed in loose mode, because map returns a Generator:

export const map = transform =>
  function*(iterable) {
    for (const item of iterable) {
      yield transform(item);
    }
  };

I wouldn't call it obvious that spread doesn't work for all Iterable's.

[fdanielsen]

@kasperpeulen Agreed. Just hit this myself upgrading to Babel v7, where NodeList does not get converted to an array in loose mode.

[nicolo-ribaudo]

I'm closing this for two reasons:

• Loose mode is meant to work only in a specific subset of all the possible cases
• We are introducing the assumptions options, that will make it easier to configure how array spread is compiled (Replace "loose" options with a top-level "assumptions" object rfcs#5)