Class static property assigned outside of the class body becomes read-only (`--allowJs`)

[nd0ut]

Bug Report

🔎 Search Terms

• javascript
• static class property
• assign outside of the class body
• declaration
• namespace
• read-only
• allowJs

🕗 Version & Regression Information

• This is the behavior in every version I tried (4.9.5 and 5.1.0-dev.20230227), and I reviewed the FAQ for entries.

⏯ Playground Link

For some reason, there is no assert emitted in the workbench. But it's emitted when you run tsc manually.

Workbench link with relevant code

💻 Code

// @declaration
// @emitDeclarationOnly
// @filename: Foo.js
class Base {
  static foo = '';
}
export class Foo extends Base {}
Foo.foo = 'foo';

// @filename: Bar.ts
import { Foo } from './Foo.js';

class Bar extends Foo {}
Bar.foo = 'foo';

🙁 Actual behavior

Here is generated FooJS.d.ts:

export class FooJS extends BaseJS {
}
export namespace FooJS {
    const foo: string;
}
declare class BaseJS {
    static foo: string;
}
export {};

There shouldn't be a namespace because foo is inherited static property.
We got error TS2540: Cannot assign to 'foo' because it is a read-only property. as a consequence.

This problem is only reproduced when emitting declarations for javascript files. For TS files it's OK - see workbench.

🙂 Expected behavior

Generated FooJS.d.ts shouldn't contain namespace:

export class FooJS extends BaseJS {
}
declare class BaseJS {
    static foo: string;
}
export {};

[RyanCavanaugh]

In the general case, we have to generate a declaration here since you might be specifying a more-specific type for Foo.foo which callers are depending on seeing. And since you wrote Foo.foo = instead of static foo = , it seems entirely reasonable to generate a namespace rather than a static initializer that you didn't write. So those behaviors seem correct.

The right fix seems like just generating let instead of const in the namespace; I agree the assumption of readonlyness doesn't seem justified.

[robpalme]

And since you wrote Foo.foo = instead of static foo = , it seems entirely reasonable to generate a namespace rather than a static initializer that you didn't write.

Given that declaration emit is synthesising a fresh compound type either way, is there a reason to prefer namespace over class? Personally I view class as more idiomatic - it's a plain JS thing - and it helps reduce unnecessary proliferation of a lesser understood TS-only concept. (I realize DTS files are already inherently a TS thing so this is a subjective view)

[RyanCavanaugh]

I don't have a strong technical argument apart from the general vibe that if you didn't write static foo (but could have), generating static foo seems worse than generating something else. I doubt it would break anything to change it.