Fixed declaration emit for undefined properties inferred from functions in other array elements

src/compiler/checker.ts

@@ -7154,35 +7154,36 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     const methodDeclaration = signatureToSignatureDeclarationHelper(signature, SyntaxKind.MethodSignature, context, { name: propertyName, questionToken: optionalToken }) as MethodSignature;
                     typeElements.push(preserveCommentsOn(methodDeclaration));
                 }
+                if (signatures.length || !optionalToken) {
+                    return;
+                }
+            }
+            let propertyTypeNode: TypeNode;
+            if (shouldUsePlaceholderForProperty(propertySymbol, context)) {
+                propertyTypeNode = createElidedInformationPlaceholder(context);
             }
             else {
-                let propertyTypeNode: TypeNode;
-                if (shouldUsePlaceholderForProperty(propertySymbol, context)) {
-                    propertyTypeNode = createElidedInformationPlaceholder(context);
+                if (propertyIsReverseMapped) {
+                    context.reverseMappedStack ||= [];
+                    context.reverseMappedStack.push(propertySymbol as ReverseMappedSymbol);
                 }
-                else {
-                    if (propertyIsReverseMapped) {
-                        context.reverseMappedStack ||= [];
-                        context.reverseMappedStack.push(propertySymbol as ReverseMappedSymbol);
-                    }
-                    propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);
-                    if (propertyIsReverseMapped) {
-                        context.reverseMappedStack!.pop();
-                    }
+                propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);
+                if (propertyIsReverseMapped) {
+                    context.reverseMappedStack!.pop();
                 }
+            }
 
-                const modifiers = isReadonlySymbol(propertySymbol) ? [factory.createToken(SyntaxKind.ReadonlyKeyword)] : undefined;
-                if (modifiers) {
-                    context.approximateLength += 9;
-                }
-                const propertySignature = factory.createPropertySignature(
-                    modifiers,
-                    propertyName,
-                    optionalToken,
-                    propertyTypeNode);
-
-                typeElements.push(preserveCommentsOn(propertySignature));
+            const modifiers = isReadonlySymbol(propertySymbol) ? [factory.createToken(SyntaxKind.ReadonlyKeyword)] : undefined;
+            if (modifiers) {
+                context.approximateLength += 9;
             }
+            const propertySignature = factory.createPropertySignature(
+                modifiers,
+                propertyName,
+                optionalToken,
+                propertyTypeNode);
+
+            typeElements.push(preserveCommentsOn(propertySignature));
 
             function preserveCommentsOn<T extends Node>(node: T) {
                 if (some(propertySymbol.declarations, d => d.kind === SyntaxKind.JSDocPropertyTag)) {

tests/baselines/reference/declarationEmitInferredUndefinedPropFromFunctionInArray.js

@@ -0,0 +1,23 @@
+//// [declarationEmitInferredUndefinedPropFromFunctionInArray.ts]
+// repro from https://github.com/microsoft/TypeScript/issues/53914
+
+export let b = [{ foo: 0, m() {} }, { bar: 1 }];
+
+//// [declarationEmitInferredUndefinedPropFromFunctionInArray.js]
+"use strict";
+// repro from https://github.com/microsoft/TypeScript/issues/53914
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.b = void 0;
+exports.b = [{ foo: 0, m: function () { } }, { bar: 1 }];
+
+
+//// [declarationEmitInferredUndefinedPropFromFunctionInArray.d.ts]
+export declare let b: ({
+    foo: number;
+    m(): void;
+    bar?: undefined;
+} | {
+    bar: number;
+    foo?: undefined;
+    m?: undefined;
+})[];

tests/baselines/reference/declarationEmitInferredUndefinedPropFromFunctionInArray.symbols

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/declarationEmitInferredUndefinedPropFromFunctionInArray.ts ===
+// repro from https://github.com/microsoft/TypeScript/issues/53914
+
+export let b = [{ foo: 0, m() {} }, { bar: 1 }];
+>b : Symbol(b, Decl(declarationEmitInferredUndefinedPropFromFunctionInArray.ts, 2, 10))
+>foo : Symbol(foo, Decl(declarationEmitInferredUndefinedPropFromFunctionInArray.ts, 2, 17))
+>m : Symbol(m, Decl(declarationEmitInferredUndefinedPropFromFunctionInArray.ts, 2, 25))
+>bar : Symbol(bar, Decl(declarationEmitInferredUndefinedPropFromFunctionInArray.ts, 2, 37))
+

tests/baselines/reference/declarationEmitInferredUndefinedPropFromFunctionInArray.types

@@ -0,0 +1,14 @@
+=== tests/cases/compiler/declarationEmitInferredUndefinedPropFromFunctionInArray.ts ===
+// repro from https://github.com/microsoft/TypeScript/issues/53914
+
+export let b = [{ foo: 0, m() {} }, { bar: 1 }];
+>b : ({ foo: number; m(): void; bar?: undefined; } | { bar: number; foo?: undefined; m?: undefined; })[]
+>[{ foo: 0, m() {} }, { bar: 1 }] : ({ foo: number; m(): void; } | { bar: number; })[]
+>{ foo: 0, m() {} } : { foo: number; m(): void; }
+>foo : number
+>0 : 0
+>m : () => void
+>{ bar: 1 } : { bar: number; }
+>bar : number
+>1 : 1
+

tests/cases/compiler/declarationEmitInferredUndefinedPropFromFunctionInArray.ts

@@ -0,0 +1,5 @@
+// @declaration: true
+
+// repro from https://github.com/microsoft/TypeScript/issues/53914
+
+export let b = [{ foo: 0, m() {} }, { bar: 1 }];