Only remove parens for identifiers and call expressions

microsoft · Jul 12, 2019 · f22dc9d · f22dc9d
1 parent e27d260
commit f22dc9d
Show file tree

Hide file tree

Showing 3 changed files with 8 additions and 45 deletions.
diff --git a/src/services/codefixes/removeUnnecessaryAwait.ts b/src/services/codefixes/removeUnnecessaryAwait.ts
@@ -27,34 +27,7 @@ namespace ts.codefix {
         }
 
         const parenthesizedExpression = tryCast(awaitExpression.parent, isParenthesizedExpression);
-        const preserveParens = parenthesizedExpression && (
-            // (await 0).toFixed() should keep its parens (or add an extra dot for 0..toFixed())
-            isPropertyAccessExpression(parenthesizedExpression.parent) && isDecimalIntegerLiteral(awaitExpression.expression, sourceFile) ||
-            // new (await c).Class()
-            isPropertyAccessExpressionInNewExpression(parenthesizedExpression.parent) ||
-            // (await new C).foo
-            isNewExpressionWithoutParens(awaitExpression.expression)
-        );
-
-        if (preserveParens) {
-            changeTracker.replaceNode(sourceFile, awaitExpression, awaitExpression.expression);
-        }
-        else {
-            changeTracker.replaceNode(sourceFile, parenthesizedExpression || awaitExpression, awaitExpression.expression);
-        }
-    }
-
-    function isPropertyAccessExpressionInNewExpression(expression: Node) {
-        return isPropertyAccessExpression(expression) && !!findAncestor(expression, ancestor => {
-            return isPropertyAccessExpression(ancestor)
-                ? false
-                : isNewExpression(ancestor)
-                    ? true
-                    : "quit";
-        });
-    }
-
-    function isNewExpressionWithoutParens(expression: Node) {
-        return isNewExpression(expression) && expression.getLastToken() === expression.expression;
+        const removeParens = parenthesizedExpression && (isIdentifier(awaitExpression.expression) || isCallExpression(awaitExpression.expression));
+        changeTracker.replaceNode(sourceFile, removeParens ? parenthesizedExpression || awaitExpression : awaitExpression, awaitExpression.expression);
     }
 }
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
@@ -1992,10 +1992,6 @@ namespace ts {
         return typeIsAccessible ? res : undefined;
     }
 
-    export function isDecimalIntegerLiteral(node: Node, sourceFile: SourceFile): node is NumericLiteral {
-        return isNumericLiteral(node) && /^\d+$/.test(node.getText(sourceFile));
-    }
-
     export function syntaxUsuallyHasTrailingSemicolon(kind: SyntaxKind) {
         return kind === SyntaxKind.VariableStatement
             || kind === SyntaxKind.ExpressionStatement

diff --git a/tests/cases/fourslash/codeFixRemoveUnnecessaryAwait.ts b/tests/cases/fourslash/codeFixRemoveUnnecessaryAwait.ts
@@ -1,30 +1,26 @@
 /// <reference path="fourslash.ts" />
 ////declare class C { foo(): void }
-////declare function getC(): { foo: { Class: C } }
+////declare function foo(): string;
 ////async function f() {
 ////  await "";
 ////  await 0;
-////  (await "").toLowerCase();
+////  (await foo()).toLowerCase();
 ////  (await 0).toFixed();
-////  (await 3.2).toFixed();
 ////  (await new C).foo();
-////  new (await getC()).foo.Class();
 ////}
 
 verify.codeFix({
   description: ts.Diagnostics.Remove_unnecessary_await.message,
   index: 0,
   newFileContent:
 `declare class C { foo(): void }
-declare function getC(): { foo: { Class: C } }
+declare function foo(): string;
 async function f() {
   "";
   await 0;
-  (await "").toLowerCase();
+  (await foo()).toLowerCase();
   (await 0).toFixed();
-  (await 3.2).toFixed();
   (await new C).foo();
-  new (await getC()).foo.Class();
 }`
 });
 
@@ -33,14 +29,12 @@ verify.codeFixAll({
   fixId: "removeUnnecessaryAwait",
   newFileContent:
 `declare class C { foo(): void }
-declare function getC(): { foo: { Class: C } }
+declare function foo(): string;
 async function f() {
   "";
   0;
-  "".toLowerCase();
+  foo().toLowerCase();
   (0).toFixed();
-  3.2.toFixed();
   (new C).foo();
-  new (getC()).foo.Class();
 }`
 });