Fix new expression edge cases

Author: andrewbranch

src/services/codefixes/removeUnnecessaryAwait.ts

@@ -27,12 +27,34 @@ namespace ts.codefix {
         }
 
         const parenthesizedExpression = tryCast(awaitExpression.parent, isParenthesizedExpression);
-        // (await 0).toFixed() should keep its parens (or add an extra dot for 0..toFixed())
-        if (parenthesizedExpression && isPropertyAccessExpression(parenthesizedExpression.parent) && isDecimalIntegerLiteral(awaitExpression.expression)) {
+        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;
+    }
 }

src/services/utilities.ts

@@ -1992,8 +1992,8 @@ namespace ts {
         return typeIsAccessible ? res : undefined;
     }
 
-    export function isDecimalIntegerLiteral(node: Node): node is NumericLiteral {
-        return isNumericLiteral(node) && /^\d+$/.test(node.text);
+    export function isDecimalIntegerLiteral(node: Node, sourceFile: SourceFile): node is NumericLiteral {
+        return isNumericLiteral(node) && /^\d+$/.test(node.getText(sourceFile));
     }
 
     export function syntaxUsuallyHasTrailingSemicolon(kind: SyntaxKind) {

tests/cases/fourslash/codeFixRemoveUnnecessaryAwait.ts

@@ -1,34 +1,46 @@
 /// <reference path="fourslash.ts" />
+////declare class C { foo(): void }
+////declare function getC(): { foo: { Class: C } }
 ////async function f() {
 ////  await "";
 ////  await 0;
 ////  (await "").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:
-`async function f() {
+`declare class C { foo(): void }
+declare function getC(): { foo: { Class: C } }
+async function f() {
   "";
   await 0;
   (await "").toLowerCase();
   (await 0).toFixed();
   (await 3.2).toFixed();
+  (await new C).foo();
+  new (await getC()).foo.Class();
 }`
 });
 
 verify.codeFixAll({
   fixAllDescription: ts.Diagnostics.Remove_all_unnecessary_uses_of_await.message,
   fixId: "removeUnnecessaryAwait",
   newFileContent:
-`async function f() {
+`declare class C { foo(): void }
+declare function getC(): { foo: { Class: C } }
+async function f() {
   "";
   0;
   "".toLowerCase();
   (0).toFixed();
   3.2.toFixed();
+  (new C).foo();
+  new (getC()).foo.Class();
 }`
 });