Simplify: add undefined to all optional propertie

whether or not somebody tried to assign undefined to them in the
erroneous assignment

Author: sandersn

src/compiler/checker.ts

@@ -634,8 +634,7 @@ namespace ts {
             isTupleType,
             isArrayLikeType,
             isTypeInvalidDueToUnionDiscriminant,
-            getExactOptionalUnassignableProperties,
-            isExactOptionalPropertyMismatch,
+            getExactOptionalProperties,
             getAllPossiblePropertiesOfTypes,
             getSuggestedSymbolForNonexistentProperty,
             getSuggestionForNonexistentProperty,
@@ -19589,6 +19588,10 @@ namespace ts {
             return !!source && !!target && maybeTypeOfKind(source, TypeFlags.Undefined) && !!containsMissingType(target);
         }
 
+        function getExactOptionalProperties(type: Type) {
+            return getPropertiesOfType(type).filter(targetProp => containsMissingType(getTypeOfSymbol(targetProp)));
+        }
+
         function getBestMatchingType(source: Type, target: UnionOrIntersectionType, isRelatedTo = compareTypesAssignable) {
             return findMatchingDiscriminantType(source, target, isRelatedTo, /*skipPartial*/ true) ||
                 findMatchingTypeReferenceOrTypeAliasReference(source, target) ||

src/compiler/types.ts

@@ -4307,8 +4307,7 @@ namespace ts {
          * e.g. it specifies `kind: "a"` and obj has `kind: "b"`.
          */
         /* @internal */ isTypeInvalidDueToUnionDiscriminant(contextualType: Type, obj: ObjectLiteralExpression | JsxAttributes): boolean;
-        /* @internal */ getExactOptionalUnassignableProperties(source: Type, target: Type): Symbol[];
-        /* @internal */ isExactOptionalPropertyMismatch(source: Type | undefined, target: Type | undefined): boolean;
+        /* @internal */ getExactOptionalProperties(type: Type): Symbol[];
         /**
          * For a union, will include a property if it's defined in *any* of the member types.
          * So for `{ a } | { b }`, this will include both `a` and `b`.

src/services/codefixes/addOptionalPropertyUndefined.ts

@@ -50,27 +50,19 @@ namespace ts.codefix {
             return emptyArray;
         }
         const { source: sourceNode, target: targetNode } = sourceTarget;
-        const target = checker.getTypeAtLocation(targetNode);
-        const source = checker.getTypeAtLocation(sourceNode);
+        const target = shouldUseParentTypeOfProperty(sourceNode, targetNode, checker)
+            ? checker.getTypeAtLocation(targetNode.expression)
+            : checker.getTypeAtLocation(targetNode);
         if (target.symbol?.declarations?.some(d => getSourceFileOfNode(d).fileName.match(/\.d\.ts$/))) {
             return emptyArray;
         }
-        const targetPropertyType = getTargetPropertyType(checker, targetNode);
-        if (targetPropertyType && checker.isExactOptionalPropertyMismatch(source, targetPropertyType)) {
-            const s = checker.getSymbolAtLocation((targetNode as PropertyAccessExpression).name);
-            return s ? [s] : emptyArray;
-        }
-        return checker.getExactOptionalUnassignableProperties(source, target);
+        return checker.getExactOptionalProperties(target);
     }
 
-    function getTargetPropertyType(checker: TypeChecker, targetNode: Node) {
-        if (isPropertySignature(targetNode)) {
-            return checker.getTypeAtLocation(targetNode.name);
-        }
-        else if (isPropertyAccessExpression(targetNode)) {
-            return checker.getTypeOfPropertyOfType(checker.getTypeAtLocation(targetNode.expression), targetNode.name.text);
-        }
-        return undefined;
+    function shouldUseParentTypeOfProperty(sourceNode: Node, targetNode: Node, checker: TypeChecker): targetNode is PropertyAccessExpression {
+        return isPropertyAccessExpression(targetNode)
+            && !!checker.getExactOptionalProperties(checker.getTypeAtLocation(targetNode.expression)).length
+            && checker.getTypeAtLocation(sourceNode) === checker.getUndefinedType();
     }
 
     /**

tests/cases/fourslash/fixExactOptionalUnassignableProperties2.ts

@@ -105,7 +105,7 @@ interface ID {
 }
 interface More {
     a?: number | undefined
-    b?: number
+    b?: number | undefined
 }
 interface Assignment {
     a?: number | undefined

tests/cases/fourslash/fixExactOptionalUnassignableProperties6.ts

@@ -5,10 +5,12 @@
 // @Filename: fixExactOptionalUnassignableProperties6.ts
 // based on snapshotterInjected.ts in microsoft/playwright
 //// type Data = {
-////     p?: (x: number) => void,
+////     f?: (x: number) => void,
+////     additional?: number,
+////     nop: string,
 //// };
 //// declare function e(o: any): Data;
-//// e(101).p = undefined
+//// e(101).f = undefined
 verify.codeFixAvailable([
     { description: ts.Diagnostics.Add_undefined_to_optional_property_type.message }
 ]);
@@ -18,8 +20,10 @@ verify.codeFix({
     index: 0,
     newFileContent:
 `type Data = {
-    p?: ((x: number) => void) | undefined,
+    f?: ((x: number) => void) | undefined,
+    additional?: number | undefined,
+    nop: string,
 };
 declare function e(o: any): Data;
-e(101).p = undefined`,
+e(101).f = undefined`,
 });

tests/cases/fourslash/fixExactOptionalUnassignableProperties8.ts

@@ -0,0 +1,29 @@
+/// <reference path='fourslash.ts'/>
+
+// @strictNullChecks: true
+// @exactOptionalPropertyTypes: true
+// @Filename: fixExactOptionalUnassignableProperties6.ts
+// based on snapshotterInjected.ts in microsoft/playwright
+//// type Data = {
+////     x?: {
+////         y?: number
+////     }
+//// }
+//// declare var d: Data
+//// d.x = { y: undefined }
+verify.codeFixAvailable([
+    { description: ts.Diagnostics.Add_undefined_to_optional_property_type.message }
+]);
+verify.codeFix({
+    description: ts.Diagnostics.Add_undefined_to_optional_property_type.message,
+    index: 0,
+    newFileContent:
+`type Data = {
+    x?: {
+        y?: number | undefined
+    }
+}
+declare var d: Data
+d.x = { y: undefined }`,
+});
+