Emit JS this properties in declarations matching tsc's serializePropertySymbol

[Copilot]

Declaration emit skipped JS this-assigned properties when a base class already declared the same property. This made React-style this.state = ... initialization disappear from .js declaration output, while tsc still emits it.

• Declaration emit

  • The skip decision for JS this.<prop> = ... expando assignments now mirrors the checker's serializePropertySymbol (EmitResolver.IsThisPropertyAssignmentDeclarationRedundant), rather than a declaration-based heuristic gated on the constructor.
  • The assignment is omitted only when the synthesized member would be redundant with an extends base member:
    • Skip when the inherited member is identical to the assigned one (same readonly-ness, optionality, and identical type).
    • Always skip when the base member is an accessor (it merges oddly with value assignments and runs via the accessor at runtime).
    • Always skip when the base member is a method/function (this-expando props carry the ReplaceableByMethod contract, so this.method = this.method.bind(this) must not override the base method).
  • The skip is no longer gated on being inside a constructor — this. assignments add JS expando props in any method, and are emitted/skipped purely on the conditions above.
  • Only extends base types are considered. implements-clause properties are always emitted (matching tsc), since they are not inherited and the class must (re)declare them.

• Regression coverage

  • Adds a compiler test covering matching .js and .ts inputs.
  • Verifies a JS constructor assignment emits state (member type differs from the base), while the TS constructor assignment remains omitted.
  • Covers a non-constructor (method) assignment skipped via type identity with the base.
  • Covers a constructor assignment to a base accessor (skipped) and a method rebind (this.method = this.method.bind(this)) to a base method (skipped).
  • Covers an assignment to a property declared by an implements clause type, which is emitted (not skipped) and produces no declaration error.

export class C2 extends Component {
    constructor() {
        super({});
        this.state = { count: 0 };
    }
}

Now emits in .js declaration output:

export declare class C2 extends Component {
    state: {
        count: number;
    };
    constructor();
}

[Copilot]

Pull request overview

This PR adjusts declaration emit so that this.<prop> = ... assignments inside JavaScript class constructors can synthesize class members in the emitted .d.ts even when a base class already declares the same property, aligning behavior with tsc for React-style this.state = ... initialization.

Changes:

• Update declaration transformer logic to not skip base-property this assignments when they occur in a constructor.
• Add a compiler regression test covering parallel .js and .ts inputs for the same pattern.
• Add new reference baselines (.js, .types, .symbols) validating the emitted declaration differences.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
internal/transformers/declarations/transform.go	Allows constructor this assignments to synthesize properties even if the base type already declares the property.
testdata/tests/cases/compiler/jsDeclarationEmitThisAssignmentWithBaseProperty.ts	New regression test covering JS-vs-TS behavior for constructor this.state assignment with a base state property.
testdata/baselines/reference/compiler/jsDeclarationEmitThisAssignmentWithBaseProperty.js	New output + declaration baseline validating emitted state for JS C2 but not TS C2.
testdata/baselines/reference/compiler/jsDeclarationEmitThisAssignmentWithBaseProperty.types	New types baseline validating inferred type flow for the assignment pattern.
testdata/baselines/reference/compiler/jsDeclarationEmitThisAssignmentWithBaseProperty.symbols	New symbols baseline validating symbol ownership differences between JS and TS scenarios.

[Copilot]

Now skip when any base declaration is an accessor, even in constructors. Fixed in 9bf4b46.

[Copilot]

Added a non-constructor (method) assignment case (C3), plus a constructor-to-accessor case (C4), both verified skipped in the baselines. Fixed in 9bf4b46.

[weswigham]

@copilot you need to fix the TODO at the bottom of GetBaseDeclarationsForPropertyDeclaration for this to be more right - base props from implements clauses matter.

[Copilot]

@copilot you need to fix the TODO at the bottom of GetBaseDeclarationsForPropertyDeclaration for this to be more right - base props from implements clauses matter.

GetBaseDeclarationsForPropertyDeclaration now collects declarations from all base types and from implements clause types (via a new getImplementsTypes checker helper), rather than returning only the first base type's declarations. Added a test case where a JS class assigns to a property declared by an implemented type. Fixed in 8c... (latest commit).

[jakebailey]

@copilot you've introduced a dts file error, which means something is wrong.

[Copilot]

Fixed in 5304bef. The invalid .d.ts came from feeding implements-clause property declarations into the override-compat skip logic: C5's value is an accessor on the implemented WithAccessor, so it got skipped, leaving C5 missing a required member (TS2720). tsc always emits implements-clause properties and only skips writes to extends base members (inherited accessors / non-constructor writes). I reverted the base-declaration lookup to extends base types only, so C5 now emits value: number; with no dts error, and the C2/C3/C4 cases are unchanged.

[weswigham]

@copilot actually, go back and just remove the TODO - classes need to redeclare interface-inherited members anyway.

[weswigham]

I think this does need to include skipping inherited methods, too, though - this-expando props have the SymbolFlagsReplaceableByMethod tag, so a this.method = this.method.bind({}) in a subclass shouldn't override the method definition in the superclass. Skipping accessors is more of a necessity, since the symbol merges with the accessor and just... does weird stuff (and at runtime it just uses the accessor, ofc).

[weswigham]

I also don't think skipping expandos outside the constructor is at-all correct; we recognize this. assignments as adding js expando props in any method.

[weswigham]

The exact condition we used in strada (see serializePropertySymbol in checker.ts) was

                    if (
                        p.flags & SymbolFlags.Prototype || p.escapedName === "constructor" ||
                        (baseType && getPropertyOfType(baseType, p.escapedName)
                            && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)!) === isReadonlySymbol(p)
                            && (p.flags & SymbolFlags.Optional) === (getPropertyOfType(baseType, p.escapedName)!.flags & SymbolFlags.Optional)
                            && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName)!))
                    ) {
                        return [];
                    }

which is to say, skip prototype, skip constructor, and skip properties identical to those in the base type.

If we don't wanna have to come back to this again - we probably wanna replicate those conditions here.

[weswigham]

@copilot adjust the condition to match the above, rather than looking at the declaration kinds of the symbol or thisContainer to try and approximate the same thing. You can and should remove GetBaseDeclarationsForPropertyDeclaration and replace it with a new resolver method - IsPropertyIdenticalToBaseTypeProperty that implements the above logic.

[Copilot]

Reworked in 2559767 to replicate the strada serializePropertySymbol conditions in IsThisPropertyAssignmentDeclarationRedundant:

• No longer gated on the constructor — this. assignments in any method are treated as expando props.
• Skips when the inherited member is identical (same readonly-ness, optionality, and identical type).
• Always skips inherited accessors and inherited methods/functions (so this.method = this.method.bind(this) no longer overrides the base method).
• Only extends base types are considered.

Added regression cases: C3 (method assignment, skipped via type identity) and C6 (method rebind, skipped via the method check). I kept the accessor/method overrides as skips rather than implementing the accessor-emit "bonus" branch.

[Copilot]

@copilot actually, go back and just remove the TODO - classes need to redeclare interface-inherited members anyway.

Done in 2559767. Removed the TODO/implements path: the skip logic now only consults extends base types via the new IsThisPropertyAssignmentDeclarationRedundant, so implements-clause members are always (re)emitted by the class.