typescript-eslint · bradzacher · Nov 11, 2025 · Mar 3, 2025 · Mar 9, 2025 · Jul 6, 2025
diff --git a/packages/eslint-plugin/docs/rules/no-unused-private-class-members.mdx b/packages/eslint-plugin/docs/rules/no-unused-private-class-members.mdx
@@ -0,0 +1,117 @@
+---
+description: 'Disallow unused private class members.'
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-unused-private-class-members** for documentation.
+
+This rule extends the base [`eslint/no-unused-private-class-members`](https://eslint.org/docs/rules/no-unused-private-class-members) rule.
+It adds support for members declared with TypeScript's `private` keyword.
+
+## Options
+
+This rule has no options.
+
+## Examples
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+class A {
+  private foo = 123;
+}
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```tsx
+class A {
+  private foo = 123;
+
+  constructor() {
+    console.log(this.foo);
+  }
+}
+```
+
+</TabItem>
+</Tabs>
+
+## Limitations
+
+This rule does not detect the following cases:
+
+(1) Private members only used via a variable that would require type analysis to resolve the type.
+
+```ts
+type T = Foo;
+class Foo {
+  private prop = 123;
+
+  method1(a: Foo) {
+    // ✅ Detected as a usage
+    const prop = this.prop;
+
+    // ✅ Detected as a usage (variables with explicit and simple type annotations are handled)
+    const otherProp = a.prop;
+  }
+
+  method2(a: T) {
+    // ❌ NOT detected as a usage (complex type annotation that requires type information to handle)
+    const prop = a.prop;
+  }
+}
+```
+
+(2) Usages of the private member outside of the class:
+
+```ts
+class Foo {
+  private prop = 123;
+}
+
+const instance = new Foo();
+// ❌ NOT detected as a usage
+console.log(foo['prop']);
+```
+
+(3) Reassignments of `this` multiple times:
+
+```ts
+class Foo {
+  private prop = 123;
+
+  foo() {
+    const self1 = this;
+    const self2 = self1;
+    return self2.prop;
+  }
+}
+```
+
+(4) Mutable reassignments of `this`:
+
+```ts
+class Foo {
+  private prop = 123;
+  private parent: Foo | null;
+
+  foo() {
+    let self = this;
+    while (self.parent != null) {
+      self = self.parent;
+    }
+    return self.prop;
+  }
+}
+```
+
+## When Not To Use It
+
+If you don't want to be notified about unused private class members, you can safely turn this rule off.
diff --git a/packages/eslint-plugin/src/configs/eslintrc/all.ts b/packages/eslint-plugin/src/configs/eslintrc/all.ts
@@ -112,6 +112,8 @@ export = {
     '@typescript-eslint/no-unsafe-unary-minus': 'error',
     'no-unused-expressions': 'off',
     '@typescript-eslint/no-unused-expressions': 'error',
+    'no-unused-private-class-members': 'off',
+    '@typescript-eslint/no-unused-private-class-members': 'error',
     'no-unused-vars': 'off',
     '@typescript-eslint/no-unused-vars': 'error',
     'no-use-before-define': 'off',

diff --git a/packages/eslint-plugin/src/configs/flat/all.ts b/packages/eslint-plugin/src/configs/flat/all.ts
@@ -126,6 +126,8 @@ export default (
       '@typescript-eslint/no-unsafe-unary-minus': 'error',
       'no-unused-expressions': 'off',
       '@typescript-eslint/no-unused-expressions': 'error',
+      'no-unused-private-class-members': 'off',
+      '@typescript-eslint/no-unused-private-class-members': 'error',
       'no-unused-vars': 'off',
       '@typescript-eslint/no-unused-vars': 'error',
       'no-use-before-define': 'off',

diff --git a/packages/eslint-plugin/src/rules/index.ts b/packages/eslint-plugin/src/rules/index.ts
@@ -88,6 +88,7 @@ import noUnsafeReturn from './no-unsafe-return';
 import noUnsafeTypeAssertion from './no-unsafe-type-assertion';
 import noUnsafeUnaryMinus from './no-unsafe-unary-minus';
 import noUnusedExpressions from './no-unused-expressions';
+import noUnusedPrivateClassMembers from './no-unused-private-class-members';
 import noUnusedVars from './no-unused-vars';
 import noUseBeforeDefine from './no-use-before-define';
 import noUselessConstructor from './no-useless-constructor';
@@ -222,6 +223,7 @@ const rules = {
   'no-unsafe-type-assertion': noUnsafeTypeAssertion,
   'no-unsafe-unary-minus': noUnsafeUnaryMinus,
   'no-unused-expressions': noUnusedExpressions,
+  'no-unused-private-class-members': noUnusedPrivateClassMembers,
   'no-unused-vars': noUnusedVars,
   'no-use-before-define': noUseBeforeDefine,
   'no-useless-constructor': noUselessConstructor,

diff --git a/packages/eslint-plugin/src/rules/no-unused-private-class-members.ts b/packages/eslint-plugin/src/rules/no-unused-private-class-members.ts
@@ -0,0 +1,60 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+import { createRule } from '../util';
+import { analyzeClassMemberUsage } from '../util/class-scope-analyzer/classScopeAnalyzer';
+
+type Options = [];
+export type MessageIds = 'unusedPrivateClassMember';
+
+export default createRule<Options, MessageIds>({
+  name: 'no-unused-private-class-members',
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow unused private class members',
+      extendsBaseRule: true,
+      requiresTypeChecking: false,
+    },
+
+    messages: {
+      unusedPrivateClassMember:
+        "Private class member '{{classMemberName}}' is defined but never used.",
+    },
+
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      'Program:exit'(node) {
+        const result = analyzeClassMemberUsage(
+          node,
+          ESLintUtils.nullThrows(
+            context.sourceCode.scopeManager,
+            'Missing required scope manager',
+          ),
+        );
+
+        for (const classScope of result.values()) {
+          for (const member of [
+            ...classScope.members.instance.values(),
+            ...classScope.members.static.values(),
+          ]) {
+            if (
+              (!member.isPrivate() && !member.isHashPrivate()) ||
+              member.isUsed()
+            ) {
+              continue;
+            }
+
+            context.report({
+              node: member.nameNode,
+              messageId: 'unusedPrivateClassMember',
+              data: { classMemberName: member.name },
+            });
+          }
+        }
+      },
+    };
+  },
+});