Allow `abstract` modifier on construct signature in object type literal

🔍 Search Terms

'abstract' modifier cannot appear on a type member

✅ Viability Checklist

• 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, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

Allow using abstract new … constructor definition keywords in an interface, i.e. in an object form (i.e., within curly braces).

📃 Motivating Example

Consider possible definitions of:

• a function (a callable object),
• a non-abstract constructor,
• an abstract constructor.

All of those definitions can be created through type aliasing:

type Callable = () => void // ✅

type Constructor = new () => void // ✅

type ConstructorAbstract = abstract new () => void // ✅

But only the first two definitions can be created using an object form:

type Callable = { (): void } // ✅

type Constructor = { new (): void } // ✅

type ConstructorAbstract = { abstract new (): void } // ❌
//                           ^^^^^^^^
// Error: 'abstract' modifier cannot appear on a type member

Try it.

Apparently, in this form the token new is considered a method name, rather than a keyword.

I suggest making the last one a valid expression by parsing new as a keyword.

💻 Use Cases

This suggestion is mainly for visual consistency, there is no functional change sought to be. To the folks who prefer using interfaces whenever possible (like me), the requirement of using type here is somewhat unreasonable, although it doesn't pose any significant problems.

Inizia riproducendo le forme di alias di tipo accettate e la forma oggetto abstract new rifiutata nel TypeScript Playground collegato. Leggi gli esempi alla base del problema e determina come la forma oggetto dovrebbe essere analizzata e verificata dal sistema dei tipi, preservando il comportamento esistente dei membri costruttori richiamabili e non astratti. Il lavoro è completo quando la dichiarazione in forma oggetto viene accettata e si comporta in modo coerente con l'alias di tipo abstract new equivalente.