RFC: Support iterables in dangerous for-of loops

[Rich-Harris]

moved from https://gitlab.com/Rich-Harris/buble/merge_requests/109

Right now for-of loops are translated directly into typical for loops over the input's length. That's "dangerous" because it doesn't follow the spec, but works for Arrays.

This proposes adding (partial, dangerous) support for iterables to for-of loops without altering the existing fast path dangerous-for-of behavior for Arrays and other looped content which has a length property.

This is still a "dangerous" transform!

• It still uses length when available instead of iterators
• If an environment does not define Symbol (native or polyfill), it falls back to length
• If a break or throw occurs in a loop over an iterator, the iterator is not properly "closed", which can impact code that uses finally {} blocks in generators.

In order to do this, for-of loops are translated into a slightly longer form.

For example, given the input:

for ( let member of array ) {
  doSomething( member );
}

The new transform will produce:

for ( var list = array, iter = list.length === void 0 && typeof Symbol === 'function' && list[Symbol.iterator], i = iter ? iter.call(list) : -1; iter ? !(iter = i.next()).done : ++i < list.length; ) {
  var member = iter ? iter.value : list[i];

  doSomething( member );
}

Here's the same output with annotated expressions:

// Same for loop structure is kept
for (
  // Evaluate for-of's RHS (same as before)
  var list = array,
             // If the list does not have a length (preserve "dangerous" Array behavior)
      iter = list.length === void 0 &&
             // And this environment understands Symbol
             typeof Symbol === 'function' &&
             // Then get the list's defined iterator
                // Will be undefined if Symbol.iterator is undefined
                // Will be undefined if list does not define an iterator
                // Will throw if list is null/undefined (spec compliant)
             list[Symbol.iterator],
             // If an iterator function was found
         i = iter
               // Then produce an iterator
             ? iter.call(list)
               // Otherwise init an index integer
             : -1
  ; // End init, begin test
  // If an iterator is in use
  iter
    // Get the next iterator-result, returning true if it is not done
  ? !(iter = i.next()).done
    // Otherwise, increment the index and return true if it's less than the list length
  : ++i < list.length
  ;  // End test, no update
) {
  // If an iterator is in use
  var member = iter
    // Get the current value
  ? iter.value
    // Otherwise, get the index from the list
  : list[i];

  doSomething( member );
}