Add a `redeclare` keyword to redeclare class attributes, behaving like `override !:` while keeping type modifiers.

[denis-migdal]

🔍 Search Terms

redeclare
declare override

Related issues:

• override modifier should able to be used with declare modifier #51515
• Add feature to re-declare variable #37771
• Variable merging #4062

✅ 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

A redeclare keyword behaving like override + declare while keeping previous type modifiers (e.g. readonly, protected, public).

type BaseType  = {};
type Overriden = {x: number};

class A {
      protected readonly foo: BaseType;

      constructor(protected readonly faa: BaseType) {}
}

class B extends A {
    redeclare foo: Overriden;
    // equivalent to "override [protected readonly] foo!: Overriden"

    constructor( redeclare faa: Overriden ) { super(faa); }
    // idem above. Do not set faa itself.
}

We could use redeclare with modifiers, e.g. public or -readonly to override previous type modifiers:

redeclare public faa: Overriden; // make it public, do not change whether it is readonly or not, etc.
redeclare public faa;       // make it public, do not change its type, whether it is readonly or not, etc.
redeclare -readonly faa; // make it read-write, do not change its type or its visibility.

I also suggest the related changes:

• in constructor parameters, !: would mean "declare but do not set".
• using declare as an alias to !: when used in constructor parameters, or with override.

Note: redeclare could also be used in other contexts, e.g. to precise a variable type (cf related issue), but this is not in the scope of this suggestion.

📃 Motivating Example

Currently, if you want to override an attribute, you have to:

type BaseType  = {};
type Overriden = {x: number};

class A {
      protected readonly foo: BaseType;
}

class B extends A {
    override readonly foo!: Overriden;
}

However, if you forget one of the type modifier (here: protected) you would have no warnings as it might be voluntary. A reader do not know if this is a mistake or not.

By using redeclare you would ensure no type modifier is forgotten, while making intents explicit.
Indeed, if the type modifiers are modified in class A, using redeclare ensures that all subclasses has the correct type modifiers (except if explicitly stated otherwise).

Also, redeclare would enable to redeclare a type from the constructor, instead of having to provide the type twice.

type BaseType  = {};
type Overriden = {x: number};

class A {
      protected readonly foo: BaseType;
}

class B extends A {
    constructor( redeclare foo: Overriden ) { ... }
}

💻 Use Cases

1. What do you want to use this for?

Safely re-declaring classes attributes.

3. What shortcomings exist with current approaches?

• We have to rewrite all type modifiers.
• In constructors parameters, we would have useless (or even unwanted) attribute assignations.
• Without constructors parameters, requires to provide the type twice.
• With a generic base class, this is quite brittle : the base class and each of its subclasses needs to know which of the attribute might be redeclared. This could lead too an excessive amount of generic types if too much attributes.

4. What workarounds are you using in the meantime?

I use constructors parameters with the useless assignations.

[RyanCavanaugh]

🤖 Thank you for your issue! I've done some analysis to help get you started. This response is automatically generated; feel free to 👍 or 👎 this comment according to its usefulness.

Similar Issues

Here are the most similar issues I found

• (74%) microsoft/typescript#37771: Add feature to re-declare variable
• (71%) microsoft/typescript#51515: `override` modifier should able to be used with `declare` modifier
• (70%) microsoft/typescript#48290: Allow 'declare' on methods and constructor

If your issue is a duplicate of one of these, feel free to close this issue. Otherwise, no action is needed.

[denis-migdal]

2 of the issues are the one I gave as "related issues".

• Add feature to re-declare variable #37771 : wants to redeclare variables, I want to redeclare attributes.
• override modifier should able to be used with declare modifier #51515 : wants to use override with declare. My suggestion goes further, asking a redeclare keyword that keeps modifiers, as well as being able to use it in constructor parameters.
• Allow 'declare' on methods and constructor #48290 : wants to be able to use declare on methods and constructors.