feat: support TypeScript syntax in no-empty-function rule (#19551)

sethamus · web-flow · commit dcd95aafa33a · 2025-04-09T22:12:10.000+05:30
diff --git a/docs/src/rules/no-empty-function.md b/docs/src/rules/no-empty-function.md
@@ -191,6 +191,10 @@ This rule has an option to allow specific kinds of functions to be empty.
     * `"constructors"` - Class constructors.
     * `"asyncFunctions"` - Async functions.
     * `"asyncMethods"` - Async class methods and method shorthands of object literals.
+    * `"privateConstructors"` - Private class constructors. (TypeScript only)
+    * `"protectedConstructors"` - Protected class constructors. (TypeScript only)
+    * `"decoratedFunctions"` - Class methods with decorators. (TypeScript only)
+    * `"overrideMethods"` - Methods that use the override keyword. (TypeScript only)
 
 ### allow: functions
 
@@ -381,6 +385,75 @@ class A {
 
 :::
 
+### allow: privateConstructors
+
+Examples of **correct** TypeScript code for the `{ "allow": ["privateConstructors"] }` option:
+
+::: correct
+
+```ts
+/*eslint no-empty-function: ["error", { "allow": ["privateConstructors"] }]*/
+
+class A {
+    private constructor() {}
+}
+```
+
+:::
+
+### allow: protectedConstructors
+
+Examples of **correct** TypeScript code for the `{ "allow": ["protectedConstructors"] }` option:
+
+::: correct
+
+```ts
+/*eslint no-empty-function: ["error", { "allow": ["protectedConstructors"] }]*/
+
+class A {
+    protected constructor() {}
+}
+```
+
+:::
+
+### allow: decoratedFunctions
+
+Examples of **correct** TypeScript code for the `{ "allow": ["decoratedFunctions"] }` option:
+
+::: correct
+
+```ts
+/*eslint no-empty-function: ["error", { "allow": ["decoratedFunctions"] }]*/
+
+class A {
+    @decorator
+    foo() {}
+}
+```
+
+:::
+
+### allow: overrideMethods
+
+Examples of **correct** TypeScript code for the `{ "allow": ["overrideMethods"] }` option:
+
+::: correct
+
+```ts
+/*eslint no-empty-function: ["error", { "allow": ["overrideMethods"] }]*/
+
+abstract class Base {
+    abstract method(): void;
+}
+
+class Derived extends Base {
+    override method() {}
+}
+```
+
+:::
+
 ## When Not To Use It
 
 If you don't want to be notified about empty functions, then it's safe to disable this rule.
diff --git a/lib/rules/no-empty-function.js b/lib/rules/no-empty-function.js
@@ -26,6 +26,10 @@ const ALLOW_OPTIONS = Object.freeze([
 	"constructors",
 	"asyncFunctions",
 	"asyncMethods",
+	"privateConstructors",
+	"protectedConstructors",
+	"decoratedFunctions",
+	"overrideMethods",
 ]);
 
 /**
@@ -83,13 +87,24 @@ function getKind(node) {
 	return prefix + kind[0].toUpperCase() + kind.slice(1);
 }
 
+/**
+ * Checks if a constructor function has parameter properties.
+ * @param {ASTNode} node The function node to examine.
+ * @returns {boolean} True if the constructor has parameter properties, false otherwise.
+ */
+function isParameterPropertiesConstructor(node) {
+	return node.params.some(param => param.type === "TSParameterProperty");
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "suggestion",
 
 		defaultOptions: [{ allow: [] }],
@@ -123,6 +138,43 @@ module.exports = {
 		const [{ allow }] = context.options;
 		const sourceCode = context.sourceCode;
 
+		/**
+		 * Checks if the given function node is allowed to be empty.
+		 * @param {ASTNode} node The function node to check.
+		 * @returns {boolean} True if the function is allowed to be empty, false otherwise.
+		 */
+		function isAllowedEmptyFunction(node) {
+			const kind = getKind(node);
+
+			if (allow.includes(kind)) {
+				return true;
+			}
+
+			if (kind === "constructors") {
+				if (
+					(node.parent.accessibility === "private" &&
+						allow.includes("privateConstructors")) ||
+					(node.parent.accessibility === "protected" &&
+						allow.includes("protectedConstructors")) ||
+					isParameterPropertiesConstructor(node)
+				) {
+					return true;
+				}
+			}
+
+			if (/(g|s)etters|methods$/iu.test(kind)) {
+				if (
+					(node.parent.decorators?.length &&
+						allow.includes("decoratedFunctions")) ||
+					(node.parent.override && allow.includes("overrideMethods"))
+				) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
 		/**
 		 * Reports a given function node if the node matches the following patterns.
 		 *
@@ -135,15 +187,14 @@ module.exports = {
 		 * @returns {void}
 		 */
 		function reportIfEmpty(node) {
-			const kind = getKind(node);
 			const name = astUtils.getFunctionNameWithKind(node);
 			const innerComments = sourceCode.getTokens(node.body, {
 				includeComments: true,
 				filter: astUtils.isCommentToken,
 			});
 
 			if (
-				!allow.includes(kind) &&
+				!isAllowedEmptyFunction(node) &&
 				node.body.type === "BlockStatement" &&
 				node.body.body.length === 0 &&
 				innerComments.length === 0
diff --git a/tests/lib/rules/no-empty-function.js b/tests/lib/rules/no-empty-function.js
