es6 compile

[jrieken]

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

[jrieken]

@DanielRosenwasser @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)

[DanielRosenwasser]

Quick conservative workaround:

interface SymbolConstructor {
    readonly iterator: symbol;
}

declare var Symbol: SymbolConstructor;

[rbuckton]

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

[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.

[jrieken]

@rbuckton we do have a separate tsconfig.monaco.json which targets ES5.

[jrieken]

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

[jrieken]

@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.

[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...

[mjbvz]

@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]

[rbuckton]

@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 {
}

[jrieken]

re #68121 (comment)

Thanks @rbuckton!

[Astrantia]

@jrieken does this improve startup performance?