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.

Start by reproducing the accepted type-alias forms and the rejected abstract new object form in the linked TypeScript Playground. Read the motivating examples and determine how the object form should parse and type-check while preserving the existing behavior of callable and non-abstract constructor members. Done means the object-form declaration is accepted and behaves consistently with the equivalent abstract new type alias.