Port "Keep accessors as accessors in emitted anonymous class declarations"

internal/checker/checker.go

@@ -15705,14 +15705,14 @@ func (c *Checker) getWriteTypeOfSymbolWithDeferredType(symbol *ast.Symbol) *Type
 // properties deriving from set accessors will either pre-compute or defer the union or
 // intersection of the writeTypes of their constituents.
 func (c *Checker) getWriteTypeOfSymbol(symbol *ast.Symbol) *Type {
-	if symbol.Flags&ast.SymbolFlagsProperty != 0 {
-		if symbol.CheckFlags&ast.CheckFlagsSyntheticProperty != 0 {
-			if symbol.CheckFlags&ast.CheckFlagsDeferredType != 0 {
-				return c.getWriteTypeOfSymbolWithDeferredType(symbol)
-			}
-			links := c.valueSymbolLinks.Get(symbol)
-			return core.OrElse(links.writeType, links.resolvedType)
+	if symbol.CheckFlags&ast.CheckFlagsSyntheticProperty != 0 {
+		if symbol.CheckFlags&ast.CheckFlagsDeferredType != 0 {
+			return c.getWriteTypeOfSymbolWithDeferredType(symbol)
 		}
+		links := c.valueSymbolLinks.Get(symbol)
+		return core.OrElse(links.writeType, links.resolvedType)
+	}
+	if symbol.Flags&ast.SymbolFlagsProperty != 0 {
 		return c.removeMissingType(c.getTypeOfSymbol(symbol), symbol.Flags&ast.SymbolFlagsOptional != 0)
 	}
 	if symbol.Flags&ast.SymbolFlagsAccessor != 0 {
@@ -20603,6 +20603,7 @@ func (c *Checker) getUnionOrIntersectionProperty(t *Type, name string, skipObjec
 }
 
 func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name string, skipObjectFunctionPropertyAugment bool) *ast.Symbol {
+	propFlags := ast.SymbolFlagsNone
 	var singleProp *ast.Symbol
 	var propSet collections.OrderedSet[*ast.Symbol]
 	var indexTypes []*Type
@@ -20632,6 +20633,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s
 				}
 				if singleProp == nil {
 					singleProp = prop
+					propFlags = core.OrElse(prop.Flags&ast.SymbolFlagsAccessor, ast.SymbolFlagsProperty)
 				} else if prop != singleProp {
 					isInstantiation := c.getTargetSymbol(prop) == c.getTargetSymbol(singleProp)
 					// If the symbols are instances of one another with identical types - consider the symbols
@@ -20648,6 +20650,13 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s
 						}
 						propSet.Add(prop)
 					}
+					// classes created by mixins are represented as intersections
+					// and overriding a property in a derived class redefines it completely at runtime
+					// so a get accessor can't be merged with a set accessor in a base class,
+					// for that reason the accessor flags are only used when they are the same in all constituents
+					if propFlags&ast.SymbolFlagsAccessor != 0 && (prop.Flags&ast.SymbolFlagsAccessor != (propFlags & ast.SymbolFlagsAccessor)) {
+						propFlags = (propFlags &^ ast.SymbolFlagsAccessor) | ast.SymbolFlagsProperty
+					}
 				}
 				if isUnion && c.isReadonlySymbol(prop) {
 					checkFlags |= ast.CheckFlagsReadonly
@@ -20675,6 +20684,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s
 					indexInfo = c.getApplicableIndexInfoForName(t, name)
 				}
 				if indexInfo != nil {
+					propFlags = propFlags&^ast.SymbolFlagsAccessor | ast.SymbolFlagsProperty
 					checkFlags |= ast.CheckFlagsWritePartial | (core.IfElse(indexInfo.isReadonly, ast.CheckFlagsReadonly, 0))
 					if isTupleType(t) {
 						indexType := c.getRestTypeOfTupleType(t)
@@ -20767,7 +20777,7 @@ func (c *Checker) createUnionOrIntersectionProperty(containingType *Type, name s
 		propTypes = append(propTypes, t)
 	}
 	propTypes = append(propTypes, indexTypes...)
-	result := c.newSymbolEx(ast.SymbolFlagsProperty|optionalFlag, name, checkFlags|syntheticFlag)
+	result := c.newSymbolEx(propFlags|optionalFlag, name, checkFlags|syntheticFlag)
 	result.Declarations = declarations
 	if !hasNonUniformValueDeclaration && firstValueDeclaration != nil {
 		result.ValueDeclaration = firstValueDeclaration

internal/checker/nodebuilderimpl.go

@@ -2214,22 +2214,45 @@ func (b *nodeBuilderImpl) addPropertyToElementList(propertySymbol *ast.Symbol, t
 
 	if propertySymbol.Flags&ast.SymbolFlagsAccessor != 0 {
 		writeType := b.ch.getWriteTypeOfSymbol(propertySymbol)
-		if propertyType != writeType && !b.ch.isErrorType(propertyType) && !b.ch.isErrorType(writeType) {
-			getterDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindGetAccessor)
-			getterSignature := b.ch.getSignatureFromDeclaration(getterDeclaration)
-			getter := b.signatureToSignatureDeclarationHelper(getterSignature, ast.KindGetAccessor, &SignatureToSignatureDeclarationOptions{
-				name: propertyName,
-			})
-			b.setCommentRange(getter, getterDeclaration)
-			typeElements = append(typeElements, getter)
-			setterDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindSetAccessor)
-			setterSignature := b.ch.getSignatureFromDeclaration(setterDeclaration)
-			setter := b.signatureToSignatureDeclarationHelper(setterSignature, ast.KindSetAccessor, &SignatureToSignatureDeclarationOptions{
-				name: propertyName,
-			})
-			b.setCommentRange(setter, setterDeclaration)
-			typeElements = append(typeElements, setter)
-			return typeElements
+		if !b.ch.isErrorType(propertyType) && !b.ch.isErrorType(writeType) {
+			propDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindPropertyDeclaration)
+			if propertyType != writeType || propertySymbol.Parent.Flags&ast.SymbolFlagsClass != 0 && propDeclaration == nil {
+				if getterDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindGetAccessor); getterDeclaration != nil {
+					getterSignature := b.ch.getSignatureFromDeclaration(getterDeclaration)
+					getter := b.signatureToSignatureDeclarationHelper(getterSignature, ast.KindGetAccessor, &SignatureToSignatureDeclarationOptions{
+						name: propertyName,
+					})
+					b.setCommentRange(getter, getterDeclaration)
+					typeElements = append(typeElements, getter)
+				}
+				if setterDeclaration := ast.GetDeclarationOfKind(propertySymbol, ast.KindSetAccessor); setterDeclaration != nil {
+					setterSignature := b.ch.getSignatureFromDeclaration(setterDeclaration)
+					setter := b.signatureToSignatureDeclarationHelper(setterSignature, ast.KindSetAccessor, &SignatureToSignatureDeclarationOptions{
+						name: propertyName,
+					})
+					b.setCommentRange(setter, setterDeclaration)
+					typeElements = append(typeElements, setter)
+				}
+				return typeElements
+			} else if propertySymbol.Parent.Flags&ast.SymbolFlagsClass != 0 && propDeclaration != nil && core.Find(propDeclaration.ModifierNodes(), func(m *ast.Node) bool {
+				return m.Kind == ast.KindAccessorKeyword
+			}) != nil {
+				fakeGetterSignature := b.ch.newSignature(SignatureFlagsNone, nil, nil, nil, nil, propertyType, nil, 0)
+				fakeGetterDeclaration := b.signatureToSignatureDeclarationHelper(fakeGetterSignature, ast.KindGetAccessor, &SignatureToSignatureDeclarationOptions{
+					name: propertyName,
+				})
+				b.setCommentRange(fakeGetterDeclaration, propDeclaration)
+				typeElements = append(typeElements, fakeGetterDeclaration)
+
+				setterParam := b.ch.newSymbol(ast.SymbolFlagsFunctionScopedVariable, "arg")
+				b.ch.valueSymbolLinks.Get(setterParam).resolvedType = writeType
+				fakeSetterSignature := b.ch.newSignature(SignatureFlagsNone, nil, nil, nil, []*ast.Symbol{setterParam}, b.ch.voidType, nil, 0)
+				fakeSetterDeclaration := b.signatureToSignatureDeclarationHelper(fakeSetterSignature, ast.KindSetAccessor, &SignatureToSignatureDeclarationOptions{
+					name: propertyName,
+				})
+				typeElements = append(typeElements, fakeSetterDeclaration)
+				return typeElements
+			}
 		}
 	}
 

testdata/baselines/reference/submodule/compiler/declarationEmitGenericTypeParamerSerialization3.js

@@ -36,11 +36,13 @@ export const Cls = wrapper("test");
 //// [declarationEmitGenericTypeParamerSerialization3.d.ts]
 export declare function wrapper<T>(value: T): {
     new (): {
-        name: T;
+        get name(): T;
+        set name(arg: T);
     };
 };
 export declare const Cls: {
     new (): {
-        name: string;
+        get name(): string;
+        set name(arg: string);
     };
 };

testdata/baselines/reference/submodule/conformance/anonymousClassAccessorsDeclarationEmit1.js

@@ -51,14 +51,16 @@ export declare abstract class Base {
     accessor a: number;
 }
 export declare function middle(Super?: typeof Base): abstract new () => {
-    a: number;
+    get a(): number;
+    set a(arg: number);
 };
 declare class A {
     constructor(...args: any[]);
 }
 export declare function Mixin<T extends typeof A>(Super: T): {
     new (...args: any[]): {
-        myName: string;
+        get myName(): string;
+        set myName(arg: string);
     };
 } & T;
 export {};

testdata/baselines/reference/submodule/conformance/autoAccessor8.js

@@ -45,7 +45,9 @@ declare class C2 {
 }
 declare function f(): {
     new (): {
-        a: any;
+        get a(): any;
+        set a(arg: any);
     };
-    b: any;
+    get b(): any;
+    set b(arg: any);
 };

testdata/baselines/reference/submodule/conformance/mixinAccessors1.js

@@ -49,15 +49,15 @@ declare function mixin<T extends {
     new (...args: any[]): {};
 }>(superclass: T): {
     new (...args: any[]): {
-        readonly validationTarget: HTMLElement;
+        get validationTarget(): HTMLElement;
     };
 } & T;
 declare class BaseClass {
     get validationTarget(): HTMLElement;
 }
 declare const MyClass_base: {
     new (...args: any[]): {
-        readonly validationTarget: HTMLElement;
+        get validationTarget(): HTMLElement;
     };
 } & typeof BaseClass;
 declare class MyClass extends MyClass_base {

testdata/baselines/reference/submodule/conformance/mixinAccessors1.js.diff

@@ -7,22 +7,4 @@
 -"use strict";
  // https://github.com/microsoft/TypeScript/issues/58790
  function mixin(superclass) {
-     return class extends superclass {
-@@= skipped -26, +25 lines =@@
-     new (...args: any[]): {};
- }>(superclass: T): {
-     new (...args: any[]): {
--        get validationTarget(): HTMLElement;
-+        readonly validationTarget: HTMLElement;
-     };
- } & T;
- declare class BaseClass {
-@@= skipped -8, +8 lines =@@
- }
- declare const MyClass_base: {
-     new (...args: any[]): {
--        get validationTarget(): HTMLElement;
-+        readonly validationTarget: HTMLElement;
-     };
- } & typeof BaseClass;
- declare class MyClass extends MyClass_base {
+     return class extends superclass {