for..of transform when targetting ES6< [Compiler option]

Search Terms

for..of, downlevelIteration, transform, optimization, compiler option

Suggestion

Option for transforming for..of when targetting ES6 and above.

Background

Based on my investigation, for..of loops are slower than the traditional for loops (see the result: https://github.com/aminya/TypeScript-optimization)

It is pretty funny that when I target ES5, TypeScript converts for..of to the traditional loops, which makes the code faster, but I cannot do this when I target anything above ES6.

I noticed that there is "downlevelIteration" which does the opposite of what I want.

Use Cases

It enhances the performance but allows to write readable code.

Examples

// for - of
  let sum = 0
  for (const a of arr) {
    sum += a
  }

// should be transformed to:
// Traditional
  let sum = 0
  for (let i = 0, l = arr.length; i < l; ++i) {
    sum += arr[i]
  }

// or
  let sum = 0
  for (let i = 0, l = arr.length; i < l; ++i) {
    let a = arr[i]
    sum += a
  }

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Start by reviewing the existing for..of transform and the downlevelIteration compiler option, then compare emitted output for ES5 and ES6-or-later targets. The issue does not name files or tests; done would require a defined option, behavior-preserving transformation, and coverage for the shown array loop cases.