Simple first version

Doesn't cover or test any complicated variations.

Author: sandersn

src/compiler/checker.ts

@@ -633,6 +633,7 @@ namespace ts {
             isTupleType,
             isArrayLikeType,
             isTypeInvalidDueToUnionDiscriminant,
+            getExactOptionalUnassignableProperties,
             getAllPossiblePropertiesOfTypes,
             getSuggestedSymbolForNonexistentProperty,
             getSuggestionForNonexistentProperty,
@@ -17873,6 +17874,7 @@ namespace ts {
 
                 function reportErrorResults(source: Type, target: Type, result: Ternary, isComparingJsxAttributes: boolean) {
                     if (!result && reportErrors) {
+                        let message = headMessage
                         const sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
                         const targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
                         source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
@@ -17904,15 +17906,18 @@ namespace ts {
                                 return result;
                             }
                         }
+                        else if (exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(source, target).length) {
+                            message = Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties
+                        }
                         else {
                             errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
                         }
-                        if (!headMessage && maybeSuppress) {
+                        if (!message && maybeSuppress) {
                             lastSkippedInfo = [source, target];
                             // Used by, eg, missing property checking to replace the top-level message with a more informative one
                             return result;
                         }
-                        reportRelationError(headMessage, source, target);
+                        reportRelationError(message, source, target);
                     }
                 }
             }
@@ -19574,6 +19579,16 @@ namespace ts {
             return isUnitType(type) || !!(type.flags & TypeFlags.TemplateLiteral);
         }
 
+        // TODO: Only issue with source has undefined, target does not, and they are otherwise assignable/the same (or who cares)
+        function getExactOptionalUnassignableProperties(source: Type, target: Type) {
+            return checker.getPropertiesOfType(target).filter(targetProp => {
+                const sourceProp = getPropertyOfType(source, targetProp.escapedName)
+                return sourceProp && targetProp.valueDeclaration
+                    && maybeTypeOfKind(getTypeOfSymbol(sourceProp), TypeFlags.Undefined)
+                    && hasQuestionToken(targetProp.valueDeclaration)
+                    && containsMissingType(getTypeOfSymbol(targetProp)) })
+        }
+
         function getBestMatchingType(source: Type, target: UnionOrIntersectionType, isRelatedTo = compareTypesAssignable) {
             return findMatchingDiscriminantType(source, target, isRelatedTo, /*skipPartial*/ true) ||
                 findMatchingTypeReferenceOrTypeAliasReference(source, target) ||

src/compiler/diagnosticMessages.json

@@ -1698,6 +1698,10 @@
         "category": "Error",
         "code": 2374
     },
+    "Type '{0}' is not assignable to type '{1}' with exactOptionalPropertyTypes: true. Consider adding 'undefined' to the types of the target's properties.": {
+        "category": "Error",
+        "code": 2375
+    },
     "A 'super' call must be the first statement in the constructor when a class contains initialized properties, parameter properties, or private identifiers.": {
         "category": "Error",
         "code": 2376
@@ -7058,6 +7062,14 @@
         "category": "Message",
         "code": 95166
     },
+    "Add 'undefined' to all optional properties": {
+        "category": "Message",
+        "code": 95167
+    },
+    "Add 'undefined' to optional property type": {
+        "category": "Message",
+        "code": 95168
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/compiler/types.ts

@@ -4301,6 +4301,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[];
         /**
          * 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

@@ -0,0 +1,77 @@
+/* @internal */
+namespace ts.codefix {
+    const addOptionalPropertyUndefined = "addOptionalPropertyUndefined";
+
+    const errorCodes = [
+        Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code
+    ];
+
+    registerCodeFix({
+        errorCodes,
+        getCodeActions(context) {
+            const typeChecker = context.program.getTypeChecker();
+            const info = getInfo(context.sourceFile, context.span.start, typeChecker);
+            if (!info.length) {
+                return undefined;
+            }
+            // if method, it has to be rewritten to property
+            // skip any and unions with any
+            // add to existing unions
+            // parenthesise conditional types and arrows (the printer should take care of that, but it needs a test)
+            // test with destructuring, I've no idea what to do there
+            const changes = textChanges.ChangeTracker.with(context, t => addUndefinedToOptionalProperty(t, info));
+            return [createCodeFixAction(addOptionalPropertyUndefined, changes, Diagnostics.Add_undefined_to_optional_property_type, addOptionalPropertyUndefined, Diagnostics.Add_undefined_to_all_optional_properties)];
+        },
+        fixIds: [addOptionalPropertyUndefined],
+        getAllCodeActions: context => {
+            const { program } = context;
+            const checker = program.getTypeChecker();
+            const seen = new Map<string, true>();
+            return createCombinedCodeActions(textChanges.ChangeTracker.with(context, changes => {
+                eachDiagnostic(context, errorCodes, diag => {
+                    const info = getInfo(diag.file, diag.start, checker);
+                    if (!info.length) {
+                        return;
+                    }
+                    for (const add of info) {
+                        if (addToSeen(seen, add.id + "")) {
+                            addUndefinedToOptionalProperty(changes, info);
+                        }
+                    }
+                });
+            }));
+        },
+    });
+
+    function getInfo(sourceFile: SourceFile, tokenPos: number, checker: TypeChecker): Symbol[] {
+        // The target of the incorrect assignment
+        // eg
+        // this.definite = 1; -OR- definite = source
+        // ^^^^                    ^^^^^^^^
+        const targetToken = getTokenAtPosition(sourceFile, tokenPos);
+        const isOK = (isIdentifier(targetToken) || isPrivateIdentifier(targetToken))
+            && isBinaryExpression(targetToken.parent)
+            && targetToken.parent.operatorToken.kind === SyntaxKind.EqualsToken;
+        if (!isOK) {
+            // TODO: Walk up through lhs instead
+            return [];
+        }
+        const sourceNode = targetToken.parent.right;
+        // TODO: Also can apply to function calls, and then you have to get the signature, then its parameters, then the type of a particular parameter
+        // TODO: Also skip 'any' and node_modules and if target is not in node_modules or is built-in
+        return checker.getExactOptionalUnassignableProperties(checker.getTypeAtLocation(sourceNode), checker.getTypeAtLocation(targetToken))
+    }
+
+    function addUndefinedToOptionalProperty(changes: textChanges.ChangeTracker, toAdd: Symbol[]) {
+        for (const add of toAdd) {
+            const d = add.valueDeclaration
+            if (d && (isPropertySignature(d) || isPropertyDeclaration(d)) && d.type) {
+                const t = factory.createUnionTypeNode([
+                    ...d.type.kind === SyntaxKind.UnionType ? (d.type as UnionTypeNode).types : [d.type],
+                    factory.createTypeReferenceNode("undefined")
+                ])
+                changes.replaceNode(d.getSourceFile(), d.type, t)
+            }
+        }
+    }
+}

src/services/tsconfig.json

@@ -57,6 +57,7 @@
         "codefixes/addMissingDeclareProperty.ts",
         "codefixes/addMissingInvocationForDecorator.ts",
         "codefixes/addNameToNamelessParameter.ts",
+        "codefixes/addOptionalPropertyUndefined.ts",
         "codefixes/annotateWithTypeFromJSDoc.ts",
         "codefixes/convertFunctionToEs6Class.ts",
         "codefixes/convertToAsyncFunction.ts",

tests/cases/fourslash/fixExactOptionalUnassignableProperties1.ts

@@ -0,0 +1,32 @@
+/// <reference path='fourslash.ts'/>
+
+// @strictNullChecks: true
+// @exactOptionalPropertyTypes: true
+////interface I {
+////    a?: number
+////}
+////interface J {
+////    a?: number | undefined
+////}
+////declare var i: I
+////declare var j: J
+////i/**/ = j
+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:
+`interface I {
+    a?: number | undefined
+}
+interface J {
+    a?: number | undefined
+}
+declare var i: I
+declare var j: J
+i = j`,
+});
+