expanded array loses variable reference

[gajus]

import {
  map
} from 'inline-loops.macro';

map([], ([a, b]) => {
  console.log(a, b);
});

becomes:

const _iterable = [];
let _result = [];

for (let _key = 0, _length = _iterable.length, _value; _key < _length; ++_key) {
  _value = _iterable[_key];
  _result[_key] = console.log(a, b);
}

_result;

a and b are undefined.

[planttheidea]

Ah yes ... this is a current limitation, destructuring of the values in the callback is not supported with the aggressive inliner, and that should be checked against. I'll update.

[planttheidea]

Alright I just coupled this fix with the release of 1.1.0. The above result now will transpile into:

const _iterable = [];

const _fn = ([a, b]) => {
  console.log(a, b);
};

let _result = [];

for (let _key = 0, _length = _iterable.length, _value; _key < _length; ++_key) {
  _value = _iterable[_key];
  _result[_key] = _fn(_value, _key, _iterable);
}

_result;

Thanks for the issue with the precise repro, made this an easy bug to squash. If anything else comes up, let me know!

[gajus]

I am thinking if this is the best solution. This had a slight performance disadvantage. It would be nice to have a configurable warning about this. When warning is enabled, then it should suggest to use alternative syntax without destructuring to avoid the penalty of function invocation.

Perhaps this would be better as an ESLint rule, though.

[planttheidea]

This has actually been upgraded as of 1.2.0! We inline the operation almost all the time now, including in destructured param scenarios. You can check the README for the known bailout scenarios.

That said, your callout of providing a warning in the (now rare) bailout scenario is a good one. I'll make a note to add that in very soon.