Unoptimized destructuring compilation

[holiber]

TypeScript Version: 2.0

Code

// source ts code
let i = 1000;
while (i--) {
  let [a, b, c] = [1, 2, 3];
}

Expected behavior:

// compiled by babel
var i = 1000;
while (i--) {
  var a = 1;
  var b = 2;
  var c = 3;
}

Actual behavior:

// compiled by tsc
var i = 1000;
while (i--) {
    var _a = [1, 2, 3], a = _a[0], b = _a[1], c = _a[2];
}

On each iteration tsc creates new unnecessary array _a.

[HerringtonDarkholme]

I would rather say this adheres to spec.
Just consider code like this

var a = {};
var b = a;
[a.x, a.y, a.x] = [1, (a = {}), 3];

[holiber]

@HerringtonDarkholme, I agree that in your example it's impossible to compile code without allocation of new array. But if we look at babeljs compiler we can found what it generate optimized code if it's possible

// source

function possibleToOptimizeThisFunction() {
  let i = 1000;
  while (i--) {
    let [a, b, c] = [1, 2, 3];
  }
}

function impossibleToOptimizeThisFunction() {
  var a = {};
  var b = a;
  [a.x, a.y, a.x] = [1, (a = {}), 3];
}

// compiled by babel

function possibleToOptimizeThisFunction() {
  var i = 1000;
  while (i--) {
    var a = 1;
    var b = 2;
    var c = 3;
  }
}

function impossibleToOptimizeThisFunction() {
  var i = 1000;
  while (i--) {
    var a = {};
    var b = a;
    var _ref = [1, a = {}, 3];
    a.x = _ref[0];
    a.y = _ref[1];
    a.x = _ref[2];
  }
}

https://babeljs.io/repl/#?babili=false&evaluate=true&lineWrap=false&presets=es2015%2Creact%2Cstage-2&code=function%20example1()%20%7B%0A%20%20let%20i%20%3D%201000%3B%0A%20%20while%20(i--)%20%7B%0A%20%20%20%20let%20%5Ba%2C%20b%2C%20c%5D%20%3D%20%5B1%2C%202%2C%203%5D%3B%0A%20%20%7D%0A%7D%0A%0Afunction%20example2()%20%7B%0A%20%20let%20i%20%3D%201000%3B%0A%20%20while%20(i--)%20%7B%0A%20%20%20%20var%20a%20%3D%20%7B%7D%3B%0A%20%20%20%20var%20b%20%3D%20a%3B%0A%20%20%20%20%5Ba.x%2C%20a.y%2C%20a.x%5D%20%3D%20%5B1%2C%20(a%20%3D%20%7B%7D)%2C%203%5D%3B%0A%20%20%7D%0A%7D

[RyanCavanaugh]

Idly curious why you're writing the intializers this way? Why not just var a = 1, b = 2, c = 3 ?

[aluanhaddad]

I like how the output always matches the syntax being transformed, it is nicely predictable. Also, if this were added, I would want to disable it during development. I would only enable it when creating a production build because there is likely to be a performance penalty for these kinds of heuristic optimizations during transpilation. It may be small, but I would want to disable it.

Unfortunately, just the notion of toggleable optimizations would introduce a lot of additional, and in my mind unnecessary complexity into the language. I real don't like the idea of having TS dev and TS prod modes as these are in the domain of other tools.

You could argue that I am being hyperbolic by even hinting at this but I can imagine the issues requesting potential optimization x, or y, which breaks z that would crop up overnight.

[holiber]

@RyanCavanaugh, it's not problem to use var a = 1, b = 2, c = 3. But I migrating legacy project from es6 babel to typescript and I detected some losing of performance. It's hard to detect all places with such code. But it is also possible that problem not only in this issue.

[RyanCavanaugh]

Accepting PRs to emit the optimized code in the case where the initializer is an array literal of sufficient length