feat: support TypeScript syntax in no-useless-constructor (#19535)

JoshuaKGoldberg · web-flow · commit 557a0d23755f · 2025-03-21T10:24:38.000-04:00
* feat: support TypeScript syntax in no-useless-constructor

* Remove unnecessary // ...

* re-ran trunk fmt

* git checkout main -- docs/src/_data/further_reading_links.json

* touch up node.value.body check

* ...as well as test newline

* Add meta.dialects, meta.language
diff --git a/docs/src/rules/no-useless-constructor.md b/docs/src/rules/no-useless-constructor.md
@@ -77,6 +77,44 @@ class D extends A {
 
 :::
 
+This rule additionally supports TypeScript type syntax.
+
+Examples of **incorrect** TypeScript code for this rule:
+
+::: incorrect
+
+```ts
+/* eslint no-useless-constructor: "error" */
+
+class A {
+    public constructor() {}
+}
+```
+
+:::
+
+Examples of **correct** TypeScript code for this rule:
+
+::: correct
+
+```ts
+/* eslint no-useless-constructor: "error" */
+
+class A {
+    protected constructor() {}
+}
+
+class B extends A {
+    public constructor() {
+        super();
+    }
+}
+
+class C {
+    constructor(@decorated param) {}
+}
+```
+
 ## When Not To Use It
 
 If you don't want to be notified about unnecessary constructors, you can safely disable this rule.
diff --git a/lib/rules/no-useless-constructor.js b/lib/rules/no-useless-constructor.js
@@ -10,6 +10,35 @@ const astUtils = require("./utils/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
+/**
+ * Checks whether any of a method's parameters have a decorator or are a parameter property.
+ * @param {ASTNode} node A method definition node.
+ * @returns {boolean} `true` if any parameter had a decorator or is a parameter property.
+ */
+function hasDecoratorsOrParameterProperty(node) {
+	return node.value.params.some(
+		param =>
+			param.decorators?.length || param.type === "TSParameterProperty",
+	);
+}
+
+/**
+ * Checks whether a node's accessibility makes it not useless.
+ * @param {ASTNode} node A method definition node.
+ * @returns {boolean} `true` if the node has a useful accessibility.
+ */
+function hasUsefulAccessibility(node) {
+	switch (node.accessibility) {
+		case "protected":
+		case "private":
+			return true;
+		case "public":
+			return !!node.parent.parent.superClass;
+		default:
+			return false;
+	}
+}
+
 /**
  * Checks whether a given array of statements is a single call of `super`.
  * @param {ASTNode[]} body An array of statements to check.
@@ -135,6 +164,8 @@ function isRedundantSuperCall(body, ctorParams) {
 /** @type {import('../shared/types').Rule} */
 module.exports = {
 	meta: {
+		dialects: ["javascript", "typescript"],
+		language: "javascript",
 		type: "suggestion",
 
 		docs: {
@@ -160,7 +191,12 @@ module.exports = {
 		 * @returns {void}
 		 */
 		function checkForConstructor(node) {
-			if (node.kind !== "constructor") {
+			if (
+				node.kind !== "constructor" ||
+				node.value.type !== "FunctionExpression" ||
+				hasDecoratorsOrParameterProperty(node) ||
+				hasUsefulAccessibility(node)
+			) {
 				return;
 			}
 
diff --git a/tests/lib/rules/no-useless-constructor.js b/tests/lib/rules/no-useless-constructor.js
@@ -199,3 +199,169 @@ ruleTester.run("no-useless-constructor", rule, {
 		},
 	],
 });
+
+const ruleTesterTypeScript = new RuleTester({
+	languageOptions: {
+		parser: require("@typescript-eslint/parser"),
+	},
+});
+
+ruleTesterTypeScript.run("no-useless-constructor", rule, {
+	valid: [
+		`
+      declare class A {
+        constructor();
+      }
+          `,
+		`
+      class A {
+        constructor();
+      }
+          `,
+		`
+      abstract class A {
+        constructor();
+      }
+          `,
+		`
+      class A {
+        constructor(private name: string) {}
+      }
+          `,
+		`
+      class A {
+        constructor(public name: string) {}
+      }
+          `,
+		`
+      class A {
+        constructor(protected name: string) {}
+      }
+          `,
+		`
+      class A {
+        private constructor() {}
+      }
+          `,
+		`
+      class A {
+        protected constructor() {}
+      }
+          `,
+		`
+      class A extends B {
+        public constructor() {}
+      }
+          `,
+		`
+      class A extends B {
+        public constructor() {
+            super();
+        }
+      }
+          `,
+		`
+      class A extends B {
+        protected constructor(foo, bar) {
+          super(bar);
+        }
+      }
+          `,
+		`
+      class A extends B {
+        private constructor(foo, bar) {
+          super(bar);
+        }
+      }
+          `,
+		`
+      class A extends B {
+        public constructor(foo) {
+          super(foo);
+        }
+      }
+          `,
+		`
+      class A extends B {
+        public constructor(foo) {}
+      }
+          `,
+		`
+      class A {
+        constructor(foo);
+      }
+          `,
+		`
+      class A {
+        constructor(@Foo foo) {}
+      }
+          `,
+		`
+      class A {
+        constructor(@Foo foo: string) {}
+      }
+          `,
+		`
+      class A extends Object {
+        constructor(@Foo foo: string) {
+          super(foo);
+        }
+      }
+          `,
+		`
+      class A extends Object {
+        constructor(foo: string, @Bar() bar) {
+          super(foo, bar);
+        }
+      }
+          `,
+	],
+	invalid: [
+		{
+			code: `
+            class A {
+                constructor() {}
+            }
+              `,
+			errors: [
+				{
+					messageId: "noUselessConstructor",
+					suggestions: [
+						{
+							messageId: "removeConstructor",
+							output: `
+            class A {
+              ${"  "}
+            }
+              `,
+						},
+					],
+					type: "MethodDefinition",
+				},
+			],
+		},
+		{
+			code: `
+            class A {
+                public constructor() {}
+            }
+        `,
+			errors: [
+				{
+					messageId: "noUselessConstructor",
+					suggestions: [
+						{
+							messageId: "removeConstructor",
+							output: `
+            class A {
+              ${"  "}
+            }
+        `,
+						},
+					],
+					type: "MethodDefinition",
+				},
+			],
+		},
+	],
+});
