Codefix: add quick fix for missing 'new' operator

src/compiler/diagnosticMessages.json

@@ -4659,7 +4659,6 @@
         "category": "Message",
         "code": 95062
     },
-
     "Add missing enum member '{0}'": {
         "category": "Message",
         "code": 95063
@@ -4683,5 +4682,13 @@
     "Generate types for all packages without types": {
         "category": "Message",
         "code": 95068
+    },
+    "Add missing 'new' operator to call": {
+        "category": "Message",
+        "code": 95069
+    },
+    "Add missing 'new' operator to all calls": {
+        "category": "Message",
+        "code": 95070
     }
 }

src/services/codefixes/fixAddMissingNewOperator.ts

@@ -0,0 +1,34 @@
+/* @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 changes = textChanges.ChangeTracker.with(context, t => addMissingNewOperator(t, sourceFile, span));
+            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, diag)),
+    });
+
+    function addMissingNewOperator(changes: textChanges.ChangeTracker, sourceFile: SourceFile, span: TextSpan): void {
+        const call = cast(findAncestorMatchingSpan(sourceFile, span), isCallExpression);
+        changes.insertNodeAt(sourceFile, span.start, createToken(SyntaxKind.NewKeyword), { suffix: " " });
+        if (isCallExpression(call.expression)) {
+            changes.insertNodeAt(sourceFile, call.expression.getStart(sourceFile), createToken(SyntaxKind.OpenParenToken));
+            changes.insertNodeAt(sourceFile, call.expression.end, createToken(SyntaxKind.CloseParenToken));
+        }
+    }
+
+    function findAncestorMatchingSpan(sourceFile: SourceFile, span: TextSpan): Node {
+        let token = getTokenAtPosition(sourceFile, span.start);
+        const end = textSpanEnd(span);
+        while (token.end < end) {
+            token = token.parent;
+        }
+        return token;
+    }
+}

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,14 @@
+/// <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/codeFixAddMissingNew2.ts

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

tests/cases/fourslash/codeFixAddMissingNew3.ts

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

tests/cases/fourslash/codeFixAddMissingNew4.ts

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

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>();`
+});