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 caller": {
+        "category": "Message",
+        "code": 95067
+    },
+    "Add missing 'new' operator to all callers": {
+        "category": "Message",
+        "code": 95068
     }
 }

src/services/codefixes/fixAddMissingNewOperator.ts

@@ -0,0 +1,29 @@
+/* @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 identifierWithoutNew = getIdentifier(sourceFile, span.start);
+            const changes = textChanges.ChangeTracker.with(context, t => addMissingNewOperator(t, sourceFile, identifierWithoutNew));
+            return [createCodeFixAction(fixId, changes, Diagnostics.Add_missing_new_operator_to_caller, fixId, Diagnostics.Add_missing_new_operator_to_all_callers)];
+        },
+        fixIds: [fixId],
+        getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) =>
+            addMissingNewOperator(changes, context.sourceFile, getIdentifier(diag.file, diag.start))),
+    });
+
+    function getIdentifier(sourceFile: SourceFile, pos: number): Identifier {
+        const token = getTokenAtPosition(sourceFile, pos);
+        Debug.assert(token.kind === SyntaxKind.Identifier);
+        Debug.assert(isCallExpression(token.parent));
+        return <Identifier>token;
+    }
+
+    function addMissingNewOperator(changes: textChanges.ChangeTracker, sourceFile: SourceFile, identifierWithoutNew: Identifier): void {
+        const newTypeNode = createNew(identifierWithoutNew, /*typeArguments*/ undefined, /*argumentsArray*/ undefined);
+        changes.replaceNode(sourceFile, identifierWithoutNew, 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 caller",
+    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 callers",
+    newFileContent:
+`class C {
+    constructor(num?: number) {}
+}
+var a = new C();
+var b = new C(3);`
+});