Add refactor convertToOptionalChainExpression

src/compiler/checker.ts

@@ -674,6 +674,11 @@ namespace ts {
 
             getLocalTypeParametersOfClassOrInterfaceOrTypeAlias,
             isDeclarationVisible,
+            containsMatchingReference: (nodeIn, targetIn) => {
+                const node = getParseTreeNode(nodeIn);
+                const target = getParseTreeNode(targetIn);
+                return !!node && !!target && containsMatchingReference(node, target);
+            },
         };
 
         function getResolvedSignatureWorker(nodeIn: CallLikeExpression, candidatesOutArray: Signature[] | undefined, argumentCount: number | undefined, checkMode: CheckMode): Signature | undefined {

src/compiler/diagnosticMessages.json

@@ -5799,6 +5799,10 @@
         "category": "Message",
         "code": 95137
     },
+    "Convert to optional chain expression": {
+        "category": "Message",
+        "code": 95138
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/compiler/types.ts

@@ -4120,6 +4120,7 @@ namespace ts {
 
         /* @internal */ getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol: Symbol): readonly TypeParameter[] | undefined;
         /* @internal */ isDeclarationVisible(node: Declaration | AnyImportSyntax): boolean;
+        /* @internal */ containsMatchingReference(node: Node, target: Node): boolean;
     }
 
     /* @internal */

src/harness/fourslashImpl.ts

@@ -3254,9 +3254,9 @@ namespace FourSlash {
             }
         }
 
-        public applyRefactor({ refactorName, actionName, actionDescription, newContent: newContentWithRenameMarker }: FourSlashInterface.ApplyRefactorOptions) {
+        public applyRefactor({ refactorName, actionName, actionDescription, newContent: newContentWithRenameMarker, triggerReason }: FourSlashInterface.ApplyRefactorOptions) {
             const range = this.getSelection();
-            const refactors = this.getApplicableRefactorsAtSelection();
+            const refactors = this.getApplicableRefactorsAtSelection(triggerReason);
             const refactorsWithName = refactors.filter(r => r.name === refactorName);
             if (refactorsWithName.length === 0) {
                 this.raiseError(`The expected refactor: ${refactorName} is not available at the marker location.\nAvailable refactors: ${refactors.map(r => r.name)}`);

src/harness/fourslashInterfaceImpl.ts

@@ -1483,6 +1483,7 @@ namespace FourSlashInterface {
         actionName: string;
         actionDescription: string;
         newContent: NewFileContent;
+        triggerReason?: ts.RefactorTriggerReason;
     }
 
     export type ExpectedCompletionEntry = string | ExpectedCompletionEntryObject;

src/services/refactors/convertToOptionalChainExpression.ts

@@ -0,0 +1,130 @@
+/* @internal */
+namespace ts.refactor.convertToOptionalChainExpression {
+    const refactorName = "Convert to optional chain expression";
+    const convertToOptionalChainExpressionMessage = getLocaleSpecificMessage(Diagnostics.Convert_to_optional_chain_expression);
+
+    registerRefactor(refactorName, { getAvailableActions, getEditsForAction });
+
+    function getAvailableActions(context: RefactorContext): readonly ApplicableRefactorInfo[] {
+        const info = getInfo(context, context.triggerReason === "invoked");
+        if (!info) return emptyArray;
+        return [{
+            name: refactorName,
+            description: convertToOptionalChainExpressionMessage,
+            actions: [{
+                name: refactorName,
+                description: convertToOptionalChainExpressionMessage
+            }]
+        }];
+    }
+
+    function getEditsForAction(context: RefactorContext, actionName: string): RefactorEditInfo | undefined {
+        const info = getInfo(context);
+        if (!info) return undefined;
+        const edits = textChanges.ChangeTracker.with(context, t => doChange(context.file, context.program.getTypeChecker(), t, info, actionName));
+        return { edits, renameFilename: undefined, renameLocation: undefined };
+    }
+
+    interface Info {
+        fullPropertyAccess: PropertyAccessExpression,
+        firstOccurrence: Node,
+        expression: BinaryExpression | ConditionalExpression
+    }
+
+    function getInfo(context: RefactorContext, considerEmptySpans = true): Info | undefined {
+        const { file, program } = context;
+        const span = getRefactorContextSpan(context);
+
+        if (span.length === 0 && !considerEmptySpans) return undefined;
+        const forEmptySpan = span.length === 0 && considerEmptySpans;
+
+        const startToken = getTokenAtPosition(file, span.start);
+
+        const containingNode = forEmptySpan ? findAncestor(startToken, (node) => { return isExpressionStatement(node) && (isBinaryExpression(node.expression) || isConditionalExpression(node.expression)); }) : getParentNodeInSpan(startToken, file, span);
+        const expression = containingNode && isExpressionStatement(containingNode) ? containingNode.expression : containingNode;
+        if (!expression) return undefined;
+
+        const checker = program.getTypeChecker();
+
+
+        if (isBinaryExpression(expression)) {
+            const start = forEmptySpan ? expression.pos : startToken.pos;
+
+            const fullPropertyAccess = getFullPropertyAccessChain(expression);
+            if (!fullPropertyAccess) return undefined;
+            if (expression.operatorToken.kind !== SyntaxKind.AmpersandAmpersandToken && expression.operatorToken.pos <= fullPropertyAccess.pos) return undefined;
+
+            // ensure that each sequential operand in range matches the longest acceess chain
+            let checkNode = expression.left;
+            let firstOccurrence: PropertyAccessExpression | Identifier = fullPropertyAccess;
+            while (isBinaryExpression(checkNode) && checkNode.operatorToken.kind === SyntaxKind.AmpersandAmpersandToken && (isPropertyAccessExpression(checkNode.right) || isIdentifier(checkNode.right)) && checkNode.right.pos >= start) {
+                if (!checker.containsMatchingReference(fullPropertyAccess, checkNode.right)) {
+                    return undefined;
+                }
+                firstOccurrence = checkNode.right;
+                checkNode = checkNode.left;
+            }
+            // check final identifier
+            if ((isIdentifier(checkNode) || isPropertyAccessExpression(checkNode)) && checker.containsMatchingReference(fullPropertyAccess, checkNode) && checkNode.pos >= start) {
+                firstOccurrence = checkNode;
+            }
+            return firstOccurrence ? { fullPropertyAccess, firstOccurrence, expression } : undefined;
+        }
+
+        if (isConditionalExpression(expression)) {
+            const whenTrue = expression.whenTrue;
+            const condition = expression.condition;
+            if ((isIdentifier(condition) || isPropertyAccessExpression(condition)) && isPropertyAccessExpression(whenTrue) && checker.containsMatchingReference(whenTrue, condition)) {
+                // The ternary expression and nullish coalescing would result in different return values if c is nullish so do not offer a refactor
+                const type = checker.getTypeAtLocation(whenTrue.name);
+                if (checker.isNullableType(type) || type.flags & TypeFlags.Any) {
+                    return undefined;
+                }
+                return { fullPropertyAccess: whenTrue, firstOccurrence: condition, expression };
+            }
+        }
+        return undefined;
+    }
+
+    function getRightHandSidePropertyAccess(node: BinaryExpression | CallExpression): PropertyAccessExpression | undefined {
+        if (isCallExpression(node) && isPropertyAccessExpression(node.expression)) {
+            // a && |a.b|();
+            return node.expression;
+        }
+        else if (isBinaryExpression(node)) {
+            if (isPropertyAccessExpression(node.left)) {
+                // a && |a.b| == 1;
+                return node.left;
+            }
+            else if (isCallExpression(node.left) && isPropertyAccessExpression(node.left.expression)) {
+                // a && |a.b|() == 1;
+                return node.left.expression;
+            }
+        }
+        return undefined;
+    }
+
+    function getFullPropertyAccessChain(node: BinaryExpression): PropertyAccessExpression | undefined {
+        return isBinaryExpression(node.right) || isCallExpression(node.right)
+            ? getRightHandSidePropertyAccess(node.right) : node.operatorToken.kind === SyntaxKind.AmpersandAmpersandToken && isPropertyAccessExpression(node.right) && !isOptionalChain(node.right)
+                ? node.right : undefined;
+    }
+
+    function convertPropertyAccessToOptionalChain(checker: TypeChecker, toConvert: PropertyAccessExpression, until: Identifier | PrivateIdentifier): PropertyAccessExpression {
+        if (isPropertyAccessExpression(toConvert.expression) && checker.getSymbolAtLocation(toConvert.expression.name) !== checker.getSymbolAtLocation(until)) {
+            return factory.createPropertyAccessChain(convertPropertyAccessToOptionalChain(checker, toConvert.expression, until), factory.createToken(SyntaxKind.QuestionDotToken), toConvert.name);
+        }
+        return factory.createPropertyAccessChain(toConvert.expression, factory.createToken(SyntaxKind.QuestionDotToken), toConvert.name);
+    }
+
+    function doChange(sourceFile: SourceFile, checker: TypeChecker, changes: textChanges.ChangeTracker, info: Info, _actionName: string): void {
+        const { fullPropertyAccess, firstOccurrence, expression } = info;
+        const until = isPropertyAccessExpression(firstOccurrence) ? firstOccurrence.name : isIdentifier(firstOccurrence) ? firstOccurrence : fullPropertyAccess.name;
+        if (isBinaryExpression(expression)) {
+            changes.replaceNodeRange(sourceFile, firstOccurrence, fullPropertyAccess, convertPropertyAccessToOptionalChain(checker, fullPropertyAccess, until));
+        }
+        else if (isConditionalExpression(expression)) {
+            changes.replaceNode(sourceFile, expression, factory.createBinaryExpression(convertPropertyAccessToOptionalChain(checker, fullPropertyAccess, until), factory.createToken(SyntaxKind.QuestionQuestionToken), expression.whenFalse));
+        }
+    }
+}

src/services/tsconfig.json

@@ -106,6 +106,7 @@
         "codefixes/fixExpectedComma.ts",
         "refactors/convertExport.ts",
         "refactors/convertImport.ts",
+        "refactors/convertToOptionalChainExpression.ts",
         "refactors/convertOverloadListToSingleSignature.ts",
         "refactors/extractSymbol.ts",
         "refactors/extractType.ts",

tests/cases/fourslash/fourslash.ts

@@ -420,7 +420,7 @@ declare namespace FourSlashInterface {
         enableFormatting(): void;
         disableFormatting(): void;
 
-        applyRefactor(options: { refactorName: string, actionName: string, actionDescription: string, newContent: NewFileContent }): void;
+        applyRefactor(options: { refactorName: string, actionName: string, actionDescription: string, newContent: NewFileContent, triggerReason?: RefactorTriggerReason }): void;
     }
     class debug {
         printCurrentParameterHelp(): void;

tests/cases/fourslash/refactorConvertToOptionalChainExpression1.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////let a = { b: { c: 0 } };
+/////*a*/a && a.b && a.b.c;/*b*/
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to optional chain expression",
+    actionName: "Convert to optional chain expression",
+    actionDescription: "Convert to optional chain expression",
+    newContent:
+`let a = { b: { c: 0 } };
+a?.b?.c;`
+});

tests/cases/fourslash/refactorConvertToOptionalChainExpression10.ts

@@ -0,0 +1,7 @@
+/// <reference path='fourslash.ts' />
+
+////let a = { b: { c: 0 } };
+/////*a*/a && a.b && a?.b?.c;/*b*/
+
+goTo.select("a", "b");
+verify.not.refactorAvailable("Convert to optional chain expression");

tests/cases/fourslash/refactorConvertToOptionalChainExpression11.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////let a = { b: 0 };
+/////*a*/a ? a.b : "whenFalse";/*b*/
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to optional chain expression",
+    actionName: "Convert to optional chain expression",
+    actionDescription: "Convert to optional chain expression",
+    newContent:
+`let a = { b: 0 };
+a?.b ?? "whenFalse";`
+});

tests/cases/fourslash/refactorConvertToOptionalChainExpression12.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////let a = { b: { c: 0 } };
+/////*a*/a.b ? a.b.c : "whenFalse";/*b*/
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to optional chain expression",
+    actionName: "Convert to optional chain expression",
+    actionDescription: "Convert to optional chain expression",
+    newContent:
+`let a = { b: { c: 0 } };
+a.b?.c ?? "whenFalse";`
+});

tests/cases/fourslash/refactorConvertToOptionalChainExpression13.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts' />
+
+// @strict: true
+
+////interface Foo {
+////    bar?:{
+////        baz: string;
+////    }
+////}
+////declare let foo: Foo;
+/////*a*/foo.bar ? foo.bar.baz : "whenFalse";/*b*/
+
+// Offer the refactor for ternary expressions if type of baz is not any, null, unknown, or undefined
+goTo.select("a", "b");
+verify.refactorAvailable("Convert to optional chain expression");

tests/cases/fourslash/refactorConvertToOptionalChainExpression14.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts' />
+
+// @strict: true
+
+////interface Foo {
+////    bar?:{
+////        baz?: any;
+////    }
+////}
+////declare let foo: Foo;
+/////*a*/foo.bar ? foo.bar.baz : "whenFalse";/*b*/
+
+// do not offer a refactor for ternary expression if type of baz is any
+goTo.select("a", "b");
+verify.not.refactorAvailable("Convert to optional chain expression");

tests/cases/fourslash/refactorConvertToOptionalChainExpression15.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts' />
+
+// @strict: true
+
+////interface Foo {
+////    bar?:{
+////        baz?: string | null;
+////    }
+////}
+////declare let foo: Foo;
+/////*a*/foo.bar ? foo.bar.baz : "whenFalse";/*b*/
+
+// do not offer a refactor for ternary expression if type of baz is nullish
+goTo.select("a", "b");
+verify.not.refactorAvailable("Convert to optional chain expression");

tests/cases/fourslash/refactorConvertToOptionalChainExpression2.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////let a = { b: { c: () => { } } };
+/////*a*/a && a.b && a.b.c();/*b*/
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to optional chain expression",
+    actionName: "Convert to optional chain expression",
+    actionDescription: "Convert to optional chain expression",
+    newContent:
+`let a = { b: { c: () => { } } };
+a?.b?.c();`
+});

tests/cases/fourslash/refactorConvertToOptionalChainExpression3.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////let a = { b: { c: 0 } };
+/////*a*/a && a.b && a.b.c === 1;/*b*/
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to optional chain expression",
+    actionName: "Convert to optional chain expression",
+    actionDescription: "Convert to optional chain expression",
+    newContent:
+`let a = { b: { c: 0 } };
+a?.b?.c === 1;`
+});

tests/cases/fourslash/refactorConvertToOptionalChainExpression4.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////let a = { b: { c: () => { } } };
+/////*a*/a && a.b && a.b.c() === 1;/*b*/
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to optional chain expression",
+    actionName: "Convert to optional chain expression",
+    actionDescription: "Convert to optional chain expression",
+    newContent:
+`let a = { b: { c: () => { } } };
+a?.b?.c() === 1;`
+});

tests/cases/fourslash/refactorConvertToOptionalChainExpression5.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+////let a = { b: { c: 0 } };
+////if(/*a*/a && a.b && a.b.c/*b*/){};
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to optional chain expression",
+    actionName: "Convert to optional chain expression",
+    actionDescription: "Convert to optional chain expression",
+    newContent:
+`let a = { b: { c: 0 } };
+if(a?.b?.c){};`
+});

tests/cases/fourslash/refactorConvertToOptionalChainExpression6.ts

@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+////interface Foo {
+////    bar?:{
+////        baz?: string;
+////    }
+////}
+////declare let foo: Foo | undefined;
+/////*a*/foo && foo.bar && foo.bar.baz;/*b*/
+
+goTo.select("a", "b");
+edit.applyRefactor({
+    refactorName: "Convert to optional chain expression",
+    actionName: "Convert to optional chain expression",
+    actionDescription: "Convert to optional chain expression",
+    newContent:
+`interface Foo {
+    bar?:{
+        baz?: string;
+    }
+}
+declare let foo: Foo | undefined;
+foo?.bar?.baz;`
+});