feat: add new options to class-methods-use-this (#19527)

* feat: add ignoreOverrideMethods option to class-methods-use-this

* feat: add ignoreClassesWithImplements option to class-methods-use-this

* fix example

* update docs

Co-authored-by: Nicholas C. Zakas <[email protected]>

* shorten hasImplements()

Co-authored-by: Nicholas C. Zakas <[email protected]>

* tweak docs and add tests for PrivateIdentifier

* format

* tweak examples

* use ts

---------

Co-authored-by: Nicholas C. Zakas <[email protected]>

Author: sethamus

docs/src/rules/class-methods-use-this.md

@@ -106,14 +106,16 @@ class C {
 
 ## Options
 
-This rule has two options:
+This rule has four options:
 
 * `"exceptMethods"` allows specified method names to be ignored with this rule.
 * `"enforceForClassFields"` enforces that functions used as instance field initializers utilize `this`. (default: `true`)
+* `"ignoreOverrideMethods"` ignores members that are marked with the `override` modifier. (TypeScript only, default: `false`)
+* `"ignoreClassesWithImplements"` ignores class members that are defined within a class that `implements` an interface. (TypeScript only)
 
 ### exceptMethods
 
-```js
+```ts
 "class-methods-use-this": [<enabled>, { "exceptMethods": [<...exceptions>] }]
 ```
 
@@ -153,7 +155,7 @@ class A {
 
 ### enforceForClassFields
 
-```js
+```ts
 "class-methods-use-this": [<enabled>, { "enforceForClassFields": true | false }]
 ```
 
@@ -200,3 +202,164 @@ class A {
 ```
 
 :::
+
+### ignoreOverrideMethods
+
+```ts
+"class-methods-use-this": [<enabled>, { "ignoreOverrideMethods": true | false }]
+```
+
+The `ignoreOverrideMethods` option ignores members that are marked with the `override` modifier. (default: `false`)
+
+Examples of **incorrect** TypeScript code for this rule with the `{ "ignoreOverrideMethods": false }` option (default):
+
+::: incorrect
+
+```ts
+/*eslint class-methods-use-this: ["error", { "ignoreOverrideMethods": false }] */
+
+abstract class Base {
+    abstract method(): void;
+    abstract property: () => void;
+}
+
+class Derived extends Base {
+    override method() {}
+    override property = () => {};
+}
+```
+
+:::
+
+Examples of **correct** TypeScript code for this rule with the `{ "ignoreOverrideMethods": false }` option (default):
+
+::: correct
+
+```ts
+/*eslint class-methods-use-this: ["error", { "ignoreOverrideMethods": false }] */
+
+abstract class Base {
+    abstract method(): void;
+    abstract property: () => void;
+}
+
+class Derived extends Base {
+    override method() {
+        this.foo = "Hello World";
+    };
+    override property = () => {
+        this;
+    };
+}
+```
+
+:::
+
+Examples of **correct** TypeScript code for this rule with the `{ "ignoreOverrideMethods": true }` option:
+
+::: correct
+
+```ts
+/*eslint class-methods-use-this: ["error", { "ignoreOverrideMethods": true }] */
+
+abstract class Base {
+    abstract method(): void;
+    abstract property: () => void;
+}
+
+class Derived extends Base {
+    override method() {}
+    override property = () => {};
+}
+```
+
+:::
+
+### ignoreClassesWithImplements
+
+```ts
+"class-methods-use-this": [<enabled>, { "ignoreClassesWithImplements": "all" | "public-fields" }]
+```
+
+The `ignoreClassesWithImplements` ignores class members that are defined within a class that `implements` an interface. The option accepts two possible values:
+
+* `"all"` - Ignores all classes that implement interfaces
+* `"public-fields"` - Only ignores public fields in classes that implement interfaces
+
+Examples of **incorrect** TypeScript code for this rule with the `{ "ignoreClassesWithImplements": "all" }`:
+
+::: incorrect
+
+```ts
+/*eslint class-methods-use-this: ["error", { "ignoreClassesWithImplements": "all" }] */
+
+class Standalone {
+    method() {}
+    property = () => {};
+}
+```
+
+:::
+
+Examples of **correct** TypeScript code for this rule with the `{ "ignoreClassesWithImplements": "all" }` option:
+
+::: correct
+
+```ts
+/*eslint class-methods-use-this: ["error", { "ignoreClassesWithImplements": "all" }] */
+
+interface Base {
+    method(): void;
+}
+
+class Derived implements Base {
+    method() {}
+    property = () => {};
+}
+```
+
+:::
+
+Examples of **incorrect** TypeScript code for this rule with the `{ "ignoreClassesWithImplements": "public-fields" }` option:
+
+::: incorrect
+
+```ts
+/*eslint class-methods-use-this: ["error", { "ignoreClassesWithImplements": "public-fields" }] */
+
+interface Base {
+    method(): void;
+}
+
+class Derived implements Base {
+    method() {}
+    property = () => {};
+
+    private privateMethod() {}
+    private privateProperty = () => {};
+
+    protected protectedMethod() {}
+    protected protectedProperty = () => {};
+}
+```
+
+:::
+
+Examples of **correct** TypeScript code for this rule with the `{ "ignoreClassesWithImplements": "public-fields" }` option:
+
+::: correct
+
+```ts
+/*eslint class-methods-use-this: ["error", { "ignoreClassesWithImplements": "public-fields" }] */
+
+interface Base {
+    method(): void;
+}
+
+class Derived implements Base {
+    method() {}
+    property = () => {};
+}
+```
+
+:::

lib/rules/class-methods-use-this.js

@@ -26,6 +26,7 @@ module.exports = {
 			{
 				enforceForClassFields: true,
 				exceptMethods: [],
+				ignoreOverrideMethods: false,
 			},
 		],
 
@@ -48,6 +49,12 @@ module.exports = {
 					enforceForClassFields: {
 						type: "boolean",
 					},
+					ignoreOverrideMethods: {
+						type: "boolean",
+					},
+					ignoreClassesWithImplements: {
+						enum: ["all", "public-fields"],
+					},
 				},
 				additionalProperties: false,
 			},
@@ -59,7 +66,11 @@ module.exports = {
 	},
 	create(context) {
 		const [options] = context.options;
-		const { enforceForClassFields } = options;
+		const {
+			enforceForClassFields,
+			ignoreOverrideMethods,
+			ignoreClassesWithImplements,
+		} = options;
 		const exceptMethods = new Set(options.exceptMethods);
 
 		const stack = [];
@@ -107,6 +118,20 @@ module.exports = {
 			}
 		}
 
+		/**
+		 * Check if the node's parent class implements any interfaces
+		 * @param {ASTNode} node node to check
+		 * @returns {boolean} True if parent class implements interfaces
+		 * @private
+		 */
+		function hasImplements(node) {
+			const classNode = node.parent.parent;
+			return (
+				classNode?.type === "ClassDeclaration" &&
+				classNode.implements?.length > 0
+			);
+		}
+
 		/**
 		 * Check if the node is an instance method not excluded by config
 		 * @param {ASTNode} node node to check
@@ -119,6 +144,25 @@ module.exports = {
 					return true;
 				}
 
+				if (ignoreOverrideMethods && node.override) {
+					return false;
+				}
+
+				if (ignoreClassesWithImplements) {
+					const implementsInterfaces = hasImplements(node);
+					if (implementsInterfaces) {
+						if (
+							ignoreClassesWithImplements === "all" ||
+							(ignoreClassesWithImplements === "public-fields" &&
+								node.key.type !== "PrivateIdentifier" &&
+								(!node.accessibility ||
+									node.accessibility === "public"))
+						) {
+							return false;
+						}
+					}
+				}
+
 				const hashIfNeeded =
 					node.key.type === "PrivateIdentifier" ? "#" : "";
 				const name =