Fixed an issue with mapped property symbol not displaying added | undefined when its origin symbol was optional

src/compiler/checker.ts

@@ -6249,9 +6249,19 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     case SyntaxKind.PropertyDeclaration:
                     case SyntaxKind.PropertySignature:
                     case SyntaxKind.JSDocPropertyTag:
+                        if (!isOptionalDeclaration(declaration)) {
+                            return false;
+                        }
                         symbol ??= getSymbolOfDeclaration(declaration);
+                        if (!(symbol.flags & SymbolFlags.Property) || !(symbol as MappedSymbol).links?.mappedType) {
+                            return false;
+                        }
                         const type = getTypeOfSymbol(symbol);
-                        return !!(symbol.flags & SymbolFlags.Property && symbol.flags & SymbolFlags.Optional && isOptionalDeclaration(declaration) && (symbol as MappedSymbol).links?.mappedType && containsNonMissingUndefinedType(type));
+                        if (!containsNonMissingUndefinedType(type)) {
+                            return false;
+                        }
+                        const declaredType = getEffectiveTypeAnnotationNode(declaration);
+                        return !!(declaredType && !containsUndefinedType(getTypeFromTypeNodeWithoutContext(declaredType)));
                     case SyntaxKind.Parameter:
                     case SyntaxKind.JSDocParameterTag:
                         return requiresAddingImplicitUndefined(declaration, enclosingDeclaration);

tests/cases/fourslash/quickInfoMappedPropertyUnionUndefined1.ts

@@ -0,0 +1,29 @@
+/// <reference path="./fourslash.ts"/>
+
+// @strict: true
+// @exactOptionalPropertyTypes: true
+
+// https://github.com/microsoft/TypeScript/issues/59948
+
+//// type OptionalToUnionWithUndefined<T> = {
+////   [K in keyof T]: T extends Record<K, T[K]> ? T[K] : T[K] | undefined;
+//// };
+////
+//// type Intermidiate/*1*/ = OptionalToUnionWithUndefined<{ a?: string }>;
+//// type Literal/*2*/ = { a?: string | undefined };
+////
+//// type Res1/*3*/ = Required<Intermidiate>;
+//// type Res2/*4*/ = Required<Literal>;
+
+verify.quickInfoAt("1", `type Intermidiate = {
+    a?: string | undefined;
+}`);
+verify.quickInfoAt("2", `type Literal = {
+    a?: string | undefined;
+}`);
+verify.quickInfoAt("3", `type Res1 = {
+    a: string | undefined;
+}`);
+verify.quickInfoAt("4", `type Res2 = {
+    a: string | undefined;
+}`);

tests/cases/fourslash/quickInfoMappedPropertyUnionUndefined2.ts

@@ -0,0 +1,26 @@
+/// <reference path="./fourslash.ts"/>
+
+// @strict: true
+
+//// type OptionalToUnionWithUndefined<T> = {
+////   [K in keyof T]: T extends Record<K, T[K]> ? T[K] : T[K] | undefined;
+//// };
+////
+//// type Intermidiate/*1*/ = OptionalToUnionWithUndefined<{ a?: string }>;
+//// type Literal/*2*/ = { a?: string | undefined };
+////
+//// type Res1/*3*/ = Required<Intermidiate>;
+//// type Res2/*4*/ = Required<Literal>;
+
+verify.quickInfoAt("1", `type Intermidiate = {
+    a?: string | undefined;
+}`);
+verify.quickInfoAt("2", `type Literal = {
+    a?: string | undefined;
+}`);
+verify.quickInfoAt("3", `type Res1 = {
+    a: string;
+}`);
+verify.quickInfoAt("4", `type Res2 = {
+    a: string;
+}`);

tests/cases/fourslash/quickInfoMappedPropertyUnionUndefined3.ts

@@ -0,0 +1,13 @@
+/// <reference path="./fourslash.ts"/>
+
+// https://github.com/microsoft/TypeScript/issues/60411
+
+// @strict: true
+
+//// type UnsetUndefinedToOblivion<T> = { [P in keyof T]-?: T[P] | undefined };
+//// type SetUndefined<T> = { [P in keyof T]: T[P] | undefined };
+//// type TheWhat/**/ = SetUndefined<UnsetUndefinedToOblivion<{ a?: 1 }>>;
+
+verify.quickInfoAt("", `type TheWhat = {
+    a: 1 | undefined;
+}`);

tests/cases/fourslash/quickInfoMappedPropertyUnionUndefined4.ts

@@ -0,0 +1,11 @@
+// @strict: true
+
+//// type A/*1*/ = { [K in keyof { a?: string }]-?: string }
+//// type B/*2*/ = { [K in keyof A]: string | undefined }
+
+verify.quickInfoAt("1", `type A = {
+    a: string;
+}`);
+verify.quickInfoAt("2", `type B = {
+    a: string | undefined;
+}`);

tests/cases/fourslash/quickInfoMappedPropertyUnionUndefined5.ts

@@ -0,0 +1,23 @@
+// @strict: true
+
+// https://github.com/microsoft/TypeScript/issues/62325
+
+//// type RequiredKeys<T extends object> = {
+////   [K in keyof Required<T>]: T[K];
+//// };
+////
+//// type Foo = {
+////   a?: string;
+////   b?: number;
+////   c: string;
+////   d: boolean | undefined;
+//// };
+////
+//// type Bar/*1*/ = RequiredKeys<Foo>;
+
+verify.quickInfoAt("1", `type Bar = {
+    a: string | undefined;
+    b: number | undefined;
+    c: string;
+    d: boolean | undefined;
+}`);