Codefix: add quick fix for missing 'new' operator

src/compiler/diagnosticMessages.json

@@ -4608,7 +4608,6 @@
         "category": "Message",
         "code": 95062
     },
-
     "Add missing enum member '{0}'": {
         "category": "Message",
         "code": 95063
@@ -4619,10 +4618,18 @@
     },
     "Convert to async function":{
         "category": "Message",
-         "code": 95065
+        "code": 95065
     },
     "Convert all to async functions": {
-     "category": "Message",
-         "code": 95066
+        "category": "Message",
+        "code": 95066
+    },
+    "Add missing 'new' operator to call": {
+        "category": "Message",
+        "code": 95067
+    },
+    "Add missing 'new' operator to all calls": {
+        "category": "Message",
+        "code": 95068
     }
 }

src/services/codefixes/fixAddMissingNewOperator.ts

@@ -0,0 +1,28 @@
+/* @internal */
+namespace ts.codefix {
+    const fixId = "addMissingNewOperator";
+    const errorCodes = [Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code];
+    registerCodeFix({
+        errorCodes,
+        getCodeActions(context) {
+            const { sourceFile, span } = context;
+            const missingNewExpression = getMissingNewExpression(sourceFile, span.start);
+            const changes = textChanges.ChangeTracker.with(context, t => addMissingNewOperator(t, sourceFile, missingNewExpression));
+            return [createCodeFixAction(fixId, changes, Diagnostics.Add_missing_new_operator_to_call, fixId, Diagnostics.Add_missing_new_operator_to_all_calls)];
+        },
+        fixIds: [fixId],
+        getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) =>
+            addMissingNewOperator(changes, context.sourceFile, getMissingNewExpression(diag.file, diag.start))),
+    });
+
+    function getMissingNewExpression(sourceFile: SourceFile, pos: number): Expression {
+        const token = getTokenAtPosition(sourceFile, pos);
+        Debug.assert(isCallExpression(token.parent));
+        return <Expression>token;
+    }
+
+    function addMissingNewOperator(changes: textChanges.ChangeTracker, sourceFile: SourceFile, missingNewExpression: Expression): void {
+        const newTypeNode = createNew(missingNewExpression, /*typeArguments*/ undefined, /*argumentsArray*/ undefined);
+        changes.replaceNode(sourceFile, missingNewExpression, newTypeNode);
+    }
+}

src/services/tsconfig.json

@@ -53,6 +53,7 @@
         "codefixes/importFixes.ts",
         "codefixes/fixSpelling.ts",
         "codefixes/fixAddMissingMember.ts",
+        "codefixes/fixAddMissingNewOperator.ts",
         "codefixes/fixCannotFindModule.ts",
         "codefixes/fixClassDoesntImplementInheritedAbstractMember.ts",
         "codefixes/fixClassSuperMustPrecedeThisAccess.ts",

tests/cases/fourslash/codeFixAddMissingNew.ts

@@ -0,0 +1,13 @@
+/// <reference path='fourslash.ts' />
+
+////class C {
+////}
+////var c = C();
+
+verify.codeFix({
+    description: "Add missing 'new' operator to call",
+    index: 0,
+    newFileContent: `class C {
+}
+var c = new C();`
+});

tests/cases/fourslash/codeFixAddMissingNew_all.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+////class C {
+////    constructor(num?: number) {}
+////}
+////var a = C();
+////var b = C(3);
+
+verify.codeFixAll({
+    fixId: "addMissingNewOperator",
+    fixAllDescription: "Add missing 'new' operator to all calls",
+    newFileContent:
+`class C {
+    constructor(num?: number) {}
+}
+var a = new C();
+var b = new C(3);`
+});

tests/cases/fourslash/codeFixAddMissingNew_all_arguments.ts

@@ -0,0 +1,22 @@
+/// <reference path='fourslash.ts' />
+
+////class C<T = number> {
+////    x?: T;
+////    constructor(x: T) { this.x = x; }
+////}
+////let a = C(1, 2, 3);
+////let b = C<string>("hello");
+////let c = C<boolean>();
+
+verify.codeFixAll({
+    fixId: "addMissingNewOperator",
+    fixAllDescription: "Add missing 'new' operator to all calls",
+    newFileContent:
+`class C<T = number> {
+    x?: T;
+    constructor(x: T) { this.x = x; }
+}
+let a = new C(1, 2, 3);
+let b = new C<string>("hello");
+let c = new C<boolean>();`
+});