add code fix

Author: jtbandes

src/compiler/diagnosticMessages.json

@@ -5645,6 +5645,10 @@
         "category": "Message",
         "code": 95116
     },
+    "Remove parentheses": {
+        "category": "Message",
+        "code": 95117
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/compiler/parser.ts

@@ -4897,7 +4897,10 @@ namespace ts {
                         callExpr.expression = expression;
                         callExpr.questionDotToken = questionDotToken;
                         callExpr.typeArguments = typeArguments;
-                        callExpr.arguments = parseArgumentList();
+                        const { openParen, argumentList, closeParen } = parseArgumentList();
+                        callExpr.openParenToken = openParen;
+                        callExpr.closeParenToken = closeParen;
+                        callExpr.arguments = argumentList;
                         if (questionDotToken || tryReparseOptionalChain(expression)) {
                             callExpr.flags |= NodeFlags.OptionalChain;
                         }
@@ -4909,7 +4912,10 @@ namespace ts {
                     const callExpr = <CallExpression>createNode(SyntaxKind.CallExpression, expression.pos);
                     callExpr.expression = expression;
                     callExpr.questionDotToken = questionDotToken;
-                    callExpr.arguments = parseArgumentList();
+                    const { openParen, argumentList, closeParen } = parseArgumentList();
+                    callExpr.openParenToken = openParen;
+                    callExpr.closeParenToken = closeParen;
+                    callExpr.arguments = argumentList;
                     if (questionDotToken || tryReparseOptionalChain(expression)) {
                         callExpr.flags |= NodeFlags.OptionalChain;
                     }
@@ -4931,10 +4937,10 @@ namespace ts {
         }
 
         function parseArgumentList() {
-            parseExpected(SyntaxKind.OpenParenToken);
-            const result = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
-            parseExpected(SyntaxKind.CloseParenToken);
-            return result;
+            const openParen = parseExpectedToken(SyntaxKind.OpenParenToken);
+            const argumentList = parseDelimitedList(ParsingContext.ArgumentExpressions, parseArgumentExpression);
+            const closeParen = parseExpectedToken(SyntaxKind.CloseParenToken);
+            return { openParen, argumentList, closeParen };
         }
 
         function parseTypeArgumentsInExpression() {
@@ -5221,7 +5227,10 @@ namespace ts {
             node.expression = expression;
             node.typeArguments = typeArguments;
             if (token() === SyntaxKind.OpenParenToken) {
-                node.arguments = parseArgumentList();
+                const { openParen, argumentList, closeParen } = parseArgumentList();
+                node.openParenToken = openParen;
+                node.closeParenToken = closeParen;
+                node.arguments = argumentList;
             }
             else if (node.typeArguments) {
                 parseErrorAt(fullStart, scanner.getStartPos(), Diagnostics.A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list);

src/compiler/types.ts

@@ -769,6 +769,8 @@ namespace ts {
     export type PlusToken = Token<SyntaxKind.PlusToken>;
     export type MinusToken = Token<SyntaxKind.MinusToken>;
     export type AssertsToken = Token<SyntaxKind.AssertsKeyword>;
+    export type OpenParenToken = Token<SyntaxKind.OpenParenToken>;
+    export type CloseParenToken = Token<SyntaxKind.CloseParenToken>;
 
     export type Modifier
         = Token<SyntaxKind.AbstractKeyword>
@@ -1917,6 +1919,8 @@ namespace ts {
         expression: LeftHandSideExpression;
         questionDotToken?: QuestionDotToken;
         typeArguments?: NodeArray<TypeNode>;
+        openParenToken: OpenParenToken;
+        closeParenToken: CloseParenToken;
         arguments: NodeArray<Expression>;
     }
 
@@ -1997,6 +2001,8 @@ namespace ts {
         expression: LeftHandSideExpression;
         typeArguments?: NodeArray<TypeNode>;
         arguments?: NodeArray<Expression>;
+        openParenToken?: OpenParenToken;
+        closeParenToken?: CloseParenToken;
     }
 
     export interface TaggedTemplateExpression extends MemberExpression {

src/services/codefixes/removeAccidentalCallParentheses.ts

@@ -0,0 +1,25 @@
+/* @internal */
+namespace ts.codefix {
+    const fixId = "removeAccidentalCallParentheses";
+    const errorCodes = [
+        Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code,
+    ];
+    registerCodeFix({
+        errorCodes,
+        getCodeActions(context) {
+            let token = getTokenAtPosition(context.sourceFile, context.span.start);
+            while (token && !isCallExpression(token)) {
+                token = token.parent;
+            }
+            if (!token) {
+                return undefined;
+            }
+            const callExpression = token;
+            const changes = textChanges.ChangeTracker.with(context, t => {
+                t.deleteNodeRange(context.sourceFile, callExpression.openParenToken, callExpression.closeParenToken);
+            });
+            return [createCodeFixActionWithoutFixAll(fixId, changes, Diagnostics.Remove_parentheses)];
+        },
+        fixIds: [fixId],
+    });
+}

src/services/tsconfig.json

@@ -94,6 +94,7 @@
         "codefixes/useBigintLiteral.ts",
         "codefixes/fixAddModuleReferTypeMissingTypeof.ts",
         "codefixes/convertToMappedObjectType.ts",
+        "codefixes/removeAccidentalCallParentheses.ts",
         "codefixes/removeUnnecessaryAwait.ts",
         "codefixes/splitTypeOnlyImport.ts",
         "codefixes/convertConstToLet.ts",

tests/cases/fourslash/codeFixRemoveAccidentalCallParentheses.ts

@@ -0,0 +1,41 @@
+/// <reference path='fourslash.ts' />
+
+//// class Test24554 {
+////     get property(): number { return 1; }
+//// }
+//// function test24554(x: Test24554) {
+////     return x.property();
+//// }
+//// function test_2(x: { y: Test24554 }) {
+////     return x.y.property ( /* bye */ );
+//// }
+
+verify.codeFix({
+  description: "Remove parentheses",
+  index: 0,
+  newFileContent:
+`class Test24554 {
+    get property(): number { return 1; }
+}
+function test24554(x: Test24554) {
+    return x.property;
+}
+function test_2(x: { y: Test24554 }) {
+    return x.y.property ( /* bye */ );
+}`
+});
+
+verify.codeFix({
+  description: "Remove parentheses",
+  index: 1,
+  newFileContent:
+`class Test24554 {
+    get property(): number { return 1; }
+}
+function test24554(x: Test24554) {
+    return x.property();
+}
+function test_2(x: { y: Test24554 }) {
+    return x.y.property;
+}`
+});