es6 compile

[Johannes Rieken (jrieken)]

This is for #65372 and makes us emit es6 without dragging in es6-libraries (where possible).

[Johannes Rieken (jrieken)]

Daniel Rosenwasser (@DanielRosenwasser) Matt Bierner (@mjbvz) I cannot get this to work without es2015.iterable. Without it all destructing and for-of is illegal, independent of the downlevelIteration-switch. The downside is that es2015.iterable drags in all of Symbol which we don't want (in the monaco editor and below)

[Daniel Rosenwasser (DanielRosenwasser)]

Quick conservative workaround:

interface SymbolConstructor {
    readonly iterator: symbol;
}

declare var Symbol: SymbolConstructor;

[Ron Buckton (rbuckton)]

Is the Monaco editor also being compiled to ES6 or does it have its own tsconfig.json file?

[Ron Buckton (rbuckton)]

When you use --target es6 we use native destructuring and iteration, which requires Symbol.iterator at runtime, therefore we type-check that the array being destructured/iterated has a [Symbol.iterator]() method that can be used.

If you want to leave this out of the tsconfig.json file, one option is to add a /// <reference lib="es2015.iterable" /> to the files that need iteration.

[Johannes Rieken (jrieken)]

Ron Buckton (@rbuckton) we do have a separate tsconfig.monaco.json which targets ES5.

[Johannes Rieken (jrieken)]

This isn't in the schema but exactly what we want 🤓

[Johannes Rieken (jrieken)]

Ron Buckton (@rbuckton) you mentioned that you have a __extends-util that can make a function extend a class. Could you share that with us? Today, all extensions that extend our api class-types are broken.

[Johannes Rieken (jrieken)]

A slightly scary thing that I have encountered is this

let a: any[] = undefined;
let b = [1,2,3]

let c = [...b, ...a]

This snippet above fails to run (correctly) when emitting es6-code but runs when emitting es5-code (which uses concat). That will surely uncover a few unpleasant surprises...

[Matt Bierner (mjbvz)]

Johannes Rieken (@jrieken) I think strict null checks may help catch some of these case. With strict mode enabled, this code produces an error:

let a: any[] | undefined = undefined;
let b = [1, 2, 3]

let c = [...b, ...a]

[Ron Buckton (rbuckton)]

Johannes Rieken (@jrieken): Unfortunately, its not __extends that is the problem, but rather how we transform the call to super() in an ES5 class that extends an ES6 class. The issue is that our emit for ES5-downlevel classes uses _super.call, however ES6 classes are spec'd to throw when their internal [[Call]] slot is invoked.

We've discussed changing our down-level emit to support this hybrid approach but that wouldn't help existing packages unless they updated to a version of TypeScript that included that change and recompiled.

Another option would be to use --experimentalDecorators in your API projects and use a decorator to wrap your class in something callable:

function es5ClassCompat(target) {
    function _() { return Reflect.construct(target, arguments, this.constructor); }
    Object.defineProperty(_, "name", Object.getOwnPropertyDescriptor(target, "name"));
    Object.setPrototypeOf(_, target);
    Object.setPrototypeOf(_.prototype, target.prototype);
    return _;
}
...
@es5ClassCompat
class ES6NativeClass {
}

[Johannes Rieken (jrieken)]

re #68121 (comment)

Thanks Ron Buckton (@rbuckton)!

[Astrantia]

Johannes Rieken (@jrieken) does this improve startup performance?