Add codefix for --noImplicitThis

src/compiler/diagnosticMessages.json

@@ -5517,6 +5517,30 @@
         "category": "Message",
         "code": 95101
     },
+    "Add '@class' tag": {
+        "category": "Message",
+        "code": 95102
+    },
+    "Add '@this' tag": {
+        "category": "Message",
+        "code": 95103
+    },
+    "Add 'this' parameter.": {
+        "category": "Message",
+        "code": 95104
+    },
+    "Convert function expression '{0}' to arrow function": {
+        "category": "Message",
+        "code": 95105
+    },
+    "Convert function declaration '{0}' to arrow function": {
+        "category": "Message",
+        "code": 95106
+    },
+    "Fix all implicit-'this' errors": {
+        "category": "Message",
+        "code": 95107
+    },
 
     "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer.": {
         "category": "Error",

src/compiler/factoryPublic.ts

@@ -2466,6 +2466,12 @@ namespace ts {
         return tag;
     }
 
+    /* @internal */
+    export function createJSDocClassTag(): JSDocClassTag {
+        return createJSDocTag<JSDocClassTag>(SyntaxKind.JSDocClassTag, "class");
+    }
+
+
     /* @internal */
     export function createJSDocComment(comment?: string | undefined, tags?: NodeArray<JSDocTag> | undefined) {
         const node = createSynthesizedNode(SyntaxKind.JSDocComment) as JSDoc;

src/services/codefixes/fixImplicitThis.ts

@@ -0,0 +1,61 @@
+/* @internal */
+namespace ts.codefix {
+    const fixId = "fixImplicitThis";
+    const errorCodes = [Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code];
+    registerCodeFix({
+        errorCodes,
+        getCodeActions(context) {
+            const { sourceFile, program, span } = context;
+            let diagnostic: DiagnosticAndArguments | undefined;
+            const changes = textChanges.ChangeTracker.with(context, t => {
+                diagnostic = doChange(t, sourceFile, span.start, program.getTypeChecker());
+            });
+            return diagnostic ? [createCodeFixAction(fixId, changes, diagnostic, fixId, Diagnostics.Fix_all_implicit_this_errors)] : emptyArray;
+        },
+        fixIds: [fixId],
+        getAllCodeActions: context => codeFixAll(context, errorCodes, (changes, diag) => {
+            doChange(changes, diag.file, diag.start, context.program.getTypeChecker());
+        }),
+    });
+
+    function doChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number, checker: TypeChecker): DiagnosticAndArguments | undefined {
+        const token = getTokenAtPosition(sourceFile, pos);
+        Debug.assert(token.kind === SyntaxKind.ThisKeyword);
+
+        const fn = getThisContainer(token, /*includeArrowFunctions*/ false);
+        if (!isFunctionDeclaration(fn) && !isFunctionExpression(fn)) return undefined;
+
+        if (!isSourceFile(getThisContainer(fn, /*includeArrowFunctions*/ false))) { // 'this' is defined outside, convert to arrow function
+            const fnKeyword = Debug.assertDefined(findChildOfKind(fn, SyntaxKind.FunctionKeyword, sourceFile));
+            const { name } = fn;
+            const body = Debug.assertDefined(fn.body); // Should be defined because the function contained a 'this' expression
+            if (isFunctionExpression(fn)) {
+                if (name && FindAllReferences.Core.isSymbolReferencedInFile(name, checker, sourceFile, body)) {
+                    // Function expression references itself. To fix we would have to extract it to a const.
+                    return undefined;
+                }
+
+                // `function() {}` --> `() => {}`
+                changes.delete(sourceFile, fnKeyword);
+                if (name) {
+                    changes.delete(sourceFile, name);
+                }
+                changes.insertText(sourceFile, body.pos, " =>");
+                return [Diagnostics.Convert_function_expression_0_to_arrow_function, name ? name.text : ANONYMOUS];
+            }
+            else {
+                // `function f() {}` => `const f = () => {}`
+                // `name` should be defined because we only do this in inner contexts, and name is only undefined for `export default function() {}`.
+                changes.replaceNode(sourceFile, fnKeyword, createToken(SyntaxKind.ConstKeyword));
+                changes.insertText(sourceFile, name!.end, " = ");
+                changes.insertText(sourceFile, body.pos, " =>");
+                return [Diagnostics.Convert_function_declaration_0_to_arrow_function, name!.text];
+            }
+        }
+        // No outer 'this', add a @class tag if in a JS constructor function
+        else if (isSourceFileJS(sourceFile) && isPropertyAccessExpression(token.parent) && isAssignmentExpression(token.parent.parent)) {
+            addJSDocTags(changes, sourceFile, fn, [createJSDocClassTag()]);
+            return Diagnostics.Add_class_tag;
+        }
+    }
+}

src/services/codefixes/inferFromUsage.ts

@@ -351,7 +351,7 @@ namespace ts.codefix {
         addJSDocTags(changes, sourceFile, signature, paramTags);
     }
 
-    function addJSDocTags(changes: textChanges.ChangeTracker, sourceFile: SourceFile, parent: HasJSDoc, newTags: readonly JSDocTag[]): void {
+    export function addJSDocTags(changes: textChanges.ChangeTracker, sourceFile: SourceFile, parent: HasJSDoc, newTags: readonly JSDocTag[]): void {
         const comments = mapDefined(parent.jsDoc, j => j.comment);
         const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);
         const unmergedNewTags = newTags.filter(newTag => !oldTags || !oldTags.some((tag, i) => {

src/services/findAllReferences.ts

@@ -1174,16 +1174,16 @@ namespace ts.FindAllReferences {
         }
 
         /** Used as a quick check for whether a symbol is used at all in a file (besides its definition). */
-        export function isSymbolReferencedInFile(definition: Identifier, checker: TypeChecker, sourceFile: SourceFile): boolean {
-            return eachSymbolReferenceInFile(definition, checker, sourceFile, () => true) || false;
+        export function isSymbolReferencedInFile(definition: Identifier, checker: TypeChecker, sourceFile: SourceFile, searchContainer: Node = sourceFile): boolean {
+            return eachSymbolReferenceInFile(definition, checker, sourceFile, () => true, searchContainer) || false;
         }
 
-        export function eachSymbolReferenceInFile<T>(definition: Identifier, checker: TypeChecker, sourceFile: SourceFile, cb: (token: Identifier) => T): T | undefined {
+        export function eachSymbolReferenceInFile<T>(definition: Identifier, checker: TypeChecker, sourceFile: SourceFile, cb: (token: Identifier) => T, searchContainer: Node = sourceFile): T | undefined {
             const symbol = isParameterPropertyDeclaration(definition.parent, definition.parent.parent)
                 ? first(checker.getSymbolsOfParameterPropertyDeclaration(definition.parent, definition.text))
                 : checker.getSymbolAtLocation(definition);
             if (!symbol) return undefined;
-            for (const token of getPossibleSymbolReferenceNodes(sourceFile, symbol.name)) {
+            for (const token of getPossibleSymbolReferenceNodes(sourceFile, symbol.name, searchContainer)) {
                 if (!isIdentifier(token) || token === definition || token.escapedText !== definition.escapedText) continue;
                 const referenceSymbol: Symbol = checker.getSymbolAtLocation(token)!; // See GH#19955 for why the type annotation is necessary
                 if (referenceSymbol === symbol

src/services/refactors/extractSymbol.ts

@@ -677,7 +677,7 @@ namespace ts.refactor.extractSymbol {
             case SyntaxKind.FunctionDeclaration:
                 return scope.name
                     ? `function '${scope.name.text}'`
-                    : "anonymous function";
+                    : ANONYMOUS;
             case SyntaxKind.ArrowFunction:
                 return "arrow function";
             case SyntaxKind.MethodDeclaration:

src/services/textChanges.ts

@@ -338,8 +338,18 @@ namespace ts.textChanges {
             });
         }
 
+        public insertFirstParameter(sourceFile: SourceFile, parameters: NodeArray<ParameterDeclaration>, newParam: ParameterDeclaration): void {
+            const p0 = firstOrUndefined(parameters);
+            if (p0) {
+                this.insertNodeBefore(sourceFile, p0, newParam);
+            }
+            else {
+                this.insertNodeAt(sourceFile, parameters.pos, newParam);
+            }
+        }
+
         public insertNodeBefore(sourceFile: SourceFile, before: Node, newNode: Node, blankLineBetween = false): void {
-            this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, {}), newNode, this.getOptionsForInsertNodeBefore(before, blankLineBetween));
+            this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, {}), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween));
         }
 
         public insertModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void {
@@ -426,15 +436,15 @@ namespace ts.textChanges {
             this.insertNodesAt(sourceFile, start, typeParameters, { prefix: "<", suffix: ">" });
         }
 
-        private getOptionsForInsertNodeBefore(before: Node, doubleNewlines: boolean): InsertNodeOptions {
+        private getOptionsForInsertNodeBefore(before: Node, inserted: Node, doubleNewlines: boolean): InsertNodeOptions {
             if (isStatement(before) || isClassElement(before)) {
                 return { suffix: doubleNewlines ? this.newLineCharacter + this.newLineCharacter : this.newLineCharacter };
             }
             else if (isVariableDeclaration(before)) { // insert `x = 1, ` into `const x = 1, y = 2;
                 return { suffix: ", " };
             }
             else if (isParameter(before)) {
-                return {};
+                return isParameter(inserted) ? { suffix: ", " } : {};
             }
             else if (isStringLiteral(before) && isImportDeclaration(before.parent) || isNamedImports(before)) {
                 return { suffix: ", " };
@@ -1278,15 +1288,23 @@ namespace ts.textChanges {
                     deleteImportBinding(changes, sourceFile, node as NamespaceImport);
                     break;
 
+                case SyntaxKind.SemicolonToken:
+                    deleteNode(changes, sourceFile, node, { trailingTriviaOption: TrailingTriviaOption.Exclude });
+                    break;
+
+                case SyntaxKind.FunctionKeyword:
+                    deleteNode(changes, sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.Exclude });
+                    break;
+
                 default:
                     if (isImportClause(node.parent) && node.parent.name === node) {
                         deleteDefaultImport(changes, sourceFile, node.parent);
                     }
-                    else if (isCallLikeExpression(node.parent)) {
+                    else if (isCallExpression(node.parent) && contains(node.parent.arguments, node)) {
                         deleteNodeInList(changes, deletedNodesInLists, sourceFile, node);
                     }
                     else {
-                        deleteNode(changes, sourceFile, node, node.kind === SyntaxKind.SemicolonToken ? { trailingTriviaOption: TrailingTriviaOption.Exclude } : undefined);
+                        deleteNode(changes, sourceFile, node);
                     }
             }
         }

src/services/tsconfig.json

@@ -55,14 +55,14 @@
         "codefixes/addMissingInvocationForDecorator.ts",
         "codefixes/addNameToNamelessParameter.ts",
         "codefixes/annotateWithTypeFromJSDoc.ts",
-        "codefixes/inferFromUsage.ts",
         "codefixes/convertFunctionToEs6Class.ts",
         "codefixes/convertToAsyncFunction.ts",
         "codefixes/convertToEs6Module.ts",
         "codefixes/correctQualifiedNameToIndexedAccessType.ts",
         "codefixes/convertToTypeOnlyExport.ts",
         "codefixes/fixClassIncorrectlyImplementsInterface.ts",
         "codefixes/importFixes.ts",
+        "codefixes/fixImplicitThis.ts",
         "codefixes/fixSpelling.ts",
         "codefixes/fixAddMissingMember.ts",
         "codefixes/fixAddMissingNewOperator.ts",
@@ -82,6 +82,7 @@
         "codefixes/fixJSDocTypes.ts",
         "codefixes/fixMissingCallParentheses.ts",
         "codefixes/fixAwaitInSyncFunction.ts",
+        "codefixes/inferFromUsage.ts",
         "codefixes/disableJsDiagnostics.ts",
         "codefixes/helpers.ts",
         "codefixes/fixInvalidImportSyntax.ts",

src/services/utilities.ts

@@ -2396,6 +2396,8 @@ namespace ts {
         return checker.getTypeAtLocation(caseClause.parent.parent.expression);
     }
 
+    export const ANONYMOUS = "anonymous function";
+
     export function getTypeNodeIfAccessible(type: Type, enclosingScope: Node, program: Program, host: LanguageServiceHost): TypeNode | undefined {
         const checker = program.getTypeChecker();
         let typeIsAccessible = true;

tests/cases/fourslash/codeFixImplicitThis_js_all.ts

@@ -0,0 +1,36 @@
+/// <reference path='fourslash.ts' />
+
+// @allowJs: true
+// @checkJs: true
+// @noImplicitThis: true
+
+// @Filename: /a.js
+////function f() {
+////    this.x = 1;
+////}
+////class C {
+////    m() {
+////        function h() {
+////            this;
+////        }
+////    }
+////}
+
+verify.codeFixAll({
+    fixId: "fixImplicitThis",
+    fixAllDescription: "Fix all implicit-'this' errors",
+    newFileContent:
+`/**
+ * @class
+ */
+function f() {
+    this.x = 1;
+}
+class C {
+    m() {
+        const h = () => {
+            this;
+        }
+    }
+}`,
+});

tests/cases/fourslash/codeFixImplicitThis_js_classTag.ts

@@ -0,0 +1,22 @@
+/// <reference path='fourslash.ts' />
+
+// @allowJs: true
+// @checkJs: true
+// @noImplicitThis: true
+
+// @Filename: /a.js
+////function f() {
+////    this.x = 1;
+////}
+
+verify.codeFix({
+    description: "Add '@class' tag",
+    index: 0,
+    newFileContent:
+`/**
+ * @class
+ */
+function f() {
+    this.x = 1;
+}`,
+});

tests/cases/fourslash/codeFixImplicitThis_js_classTag_addToComment.ts

@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+// @allowJs: true
+// @checkJs: true
+// @noImplicitThis: true
+
+// @Filename: /a.js
+/////** Doc */
+////function f() {
+////    this.x = 1;
+////}
+
+verify.codeFix({
+    description: "Add '@class' tag",
+    index: 0,
+    newFileContent:
+`/**
+ * Doc
+ * @class
+ */
+function f() {
+    this.x = 1;
+}`,
+});

tests/cases/fourslash/codeFixImplicitThis_ts_all.ts

@@ -0,0 +1,30 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitThis: true
+
+////class C {
+////    m() {
+////        function f() {
+////            this;
+////        }
+////        const g = function() {
+////            this;
+////        };
+////    }
+////}
+
+verify.codeFixAll({
+    fixId: "fixImplicitThis",
+    fixAllDescription: "Fix all implicit-'this' errors",
+    newFileContent:
+`class C {
+    m() {
+        const f = () => {
+            this;
+        }
+        const g = () => {
+            this;
+        };
+    }
+}`,
+});

tests/cases/fourslash/codeFixImplicitThis_ts_cantFixNonFunction.ts

@@ -0,0 +1,7 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitThis: true
+
+////this;
+
+verify.codeFixAvailable([]);

tests/cases/fourslash/codeFixImplicitThis_ts_functionDeclaration.ts

@@ -0,0 +1,26 @@
+/// <reference path='fourslash.ts' />
+
+// @noImplicitThis: true
+
+////class C {
+////    m() {
+////        function f() {
+////            this;
+////            f(); // self-reference OK
+////        }
+////    }
+////}
+
+verify.codeFix({
+    description: "Convert function declaration 'f' to arrow function",
+    index: 0,
+    newFileContent:
+`class C {
+    m() {
+        const f = () => {
+            this;
+            f(); // self-reference OK
+        }
+    }
+}`,
+});