Fix unassignable properties by adding undefined with exactOptionalPropertyTypes #45032
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,139 @@ | ||
| /* @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_type_of_the_target.code, | ||
| 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, | ||
| Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_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 toAdd = getPropertiesToAdd(context.sourceFile, context.span.start, typeChecker); | ||
| if (!toAdd.length) { | ||
| return undefined; | ||
| } | ||
| const changes = textChanges.ChangeTracker.with(context, t => addUndefinedToOptionalProperty(t, toAdd)); | ||
| 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<number, true>(); | ||
| return createCombinedCodeActions(textChanges.ChangeTracker.with(context, changes => { | ||
| eachDiagnostic(context, errorCodes, diag => { | ||
| const toAdd = getPropertiesToAdd(diag.file, diag.start, checker); | ||
| if (!toAdd.length) { | ||
| return; | ||
| } | ||
| let untouched = true; | ||
| for (const add of toAdd) { | ||
| if (!addToSeen(seen, getSymbolId(add))) { | ||
| untouched = false; | ||
| } | ||
| } | ||
| if (untouched) { | ||
| addUndefinedToOptionalProperty(changes, toAdd); | ||
| } | ||
| }); | ||
| })); | ||
| }, | ||
| }); | ||
|
|
||
| function getPropertiesToAdd(file: SourceFile, pos: number, checker: TypeChecker): Symbol[] { | ||
| const sourceTarget = getSourceTarget(getErrorNode(file, pos), checker); | ||
| if (!sourceTarget) { | ||
| return emptyArray; | ||
| } | ||
| const { source: sourceNode, target: targetNode } = sourceTarget; | ||
| const target = checker.getTypeAtLocation(targetNode); | ||
| const source = checker.getTypeAtLocation(sourceNode); | ||
| 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)) { | ||
|
There was a problem hiding this comment. maybe find parent type and fix all, like the other cases |
||
| const s = checker.getSymbolAtLocation((targetNode as PropertyAccessExpression).name); | ||
| return s ? [s] : emptyArray; | ||
| } | ||
| return checker.getExactOptionalUnassignableProperties(source, 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; | ||
| } | ||
| /** | ||
| * Get the part of the incorrect assignment that is useful for type-checking | ||
| * eg | ||
| * this.definite = 1; ---> `this.definite` | ||
| * ^^^^ | ||
| * definite = source ----> `definite` | ||
| * ^^^^^^^^ | ||
| */ | ||
| function getErrorNode(file: SourceFile, pos: number): MemberName | PropertyAccessExpression | undefined { | ||
| const start = getTokenAtPosition(file, pos); | ||
| return isPropertyAccessExpression(start.parent) && start.parent.expression === start ? start.parent | ||
| : isIdentifier(start) || isPrivateIdentifier(start) ? start | ||
| : undefined; | ||
| } | ||
|
|
||
| /** | ||
| * Find the source and target of the incorrect assignment. | ||
| * The call is recursive for property assignments. | ||
| */ | ||
| function getSourceTarget(errorNode: Node | undefined, checker: TypeChecker): { source: Node, target: Node } | undefined { | ||
| if (!errorNode) { | ||
| return undefined; | ||
| } | ||
| else if (isBinaryExpression(errorNode.parent) && errorNode.parent.operatorToken.kind === SyntaxKind.EqualsToken) { | ||
| return { source: errorNode.parent.right, target: errorNode.parent.left }; | ||
| } | ||
| else if (isVariableDeclaration(errorNode.parent) && errorNode.parent.initializer) { | ||
| return { source: errorNode.parent.initializer, target: errorNode.parent.name }; | ||
| } | ||
| else if (isCallExpression(errorNode.parent)) { | ||
| const n = checker.getSymbolAtLocation(errorNode.parent.expression); | ||
| if (!n?.valueDeclaration) return undefined; | ||
| if (!isExpression(errorNode)) return undefined; | ||
| const i = errorNode.parent.arguments.indexOf(errorNode); | ||
| const name = (n.valueDeclaration as any as SignatureDeclaration).parameters[i].name; | ||
| if (isIdentifier(name)) return { source: errorNode, target: name }; | ||
| } | ||
| else if (isPropertyAssignment(errorNode.parent) && isIdentifier(errorNode.parent.name) || | ||
| isShorthandPropertyAssignment(errorNode.parent)) { | ||
| const parentTarget = getSourceTarget(errorNode.parent.parent, checker); | ||
| if (!parentTarget) return undefined; | ||
| const prop = checker.getPropertyOfType(checker.getTypeAtLocation(parentTarget.target), (errorNode.parent.name as Identifier).text); | ||
| const declaration = prop?.declarations?.[0]; | ||
| if (!declaration) return undefined; | ||
| return { | ||
| source: isPropertyAssignment(errorNode.parent) ? errorNode.parent.initializer : errorNode.parent.name, | ||
| target: declaration | ||
| }; | ||
| } | ||
| return undefined; | ||
| } | ||
|
|
||
| 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); | ||
| } | ||
| } | ||
| } | ||
| } | ||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
I moved this verbatim inside the new
else