@typescript-eslint/eslint-plugin 8.46.5-alpha.0 → 8.46.5-alpha.2

package/dist/configs/eslintrc/all.d.ts

@@ -103,6 +103,8 @@ declare const _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";

package/dist/configs/eslintrc/all.js

@@ -110,6 +110,8 @@ module.exports = {
         '@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',

package/dist/configs/flat/all.js

@@ -123,6 +123,8 @@ exports.default = (plugin, parser) => [
             '@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',

package/dist/index.d.ts

@@ -105,6 +105,8 @@ declare const _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";
@@ -794,6 +796,7 @@ declare const _default: {
             allowTaggedTemplates?: boolean;
             allowTernary?: boolean;
         }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        'no-unused-private-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedPrivateClassMember", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-unused-vars': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/no-unused-vars").MessageIds, import("./rules/no-unused-vars").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-use-before-define': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUseBeforeDefine", import("./rules/no-use-before-define").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/raw-plugin.d.ts

@@ -127,6 +127,8 @@ declare const _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";
@@ -817,6 +819,7 @@ declare const _default: {
                 allowTaggedTemplates?: boolean;
                 allowTernary?: boolean;
             }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
+            'no-unused-private-class-members': TSESLint.RuleModule<"unusedPrivateClassMember", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-unused-vars': TSESLint.RuleModule<import("./rules/no-unused-vars").MessageIds, import("./rules/no-unused-vars").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-use-before-define': TSESLint.RuleModule<"noUseBeforeDefine", import("./rules/no-use-before-define").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;
             'no-useless-constructor': TSESLint.RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../rules").ESLintPluginDocs, TSESLint.RuleListener>;

package/dist/rules/index.d.ts

@@ -124,6 +124,7 @@ declare const rules: {
         allowTaggedTemplates?: boolean;
         allowTernary?: boolean;
     }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    'no-unused-private-class-members': import("@typescript-eslint/utils/ts-eslint").RuleModule<"unusedPrivateClassMember", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-unused-vars': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./no-unused-vars").MessageIds, import("./no-unused-vars").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-use-before-define': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUseBeforeDefine", import("./no-use-before-define").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     'no-useless-constructor': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noUselessConstructor" | "removeConstructor", [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;

package/dist/rules/index.js

@@ -90,6 +90,7 @@ const no_unsafe_return_1 = __importDefault(require("./no-unsafe-return"));
 const no_unsafe_type_assertion_1 = __importDefault(require("./no-unsafe-type-assertion"));
 const no_unsafe_unary_minus_1 = __importDefault(require("./no-unsafe-unary-minus"));
 const no_unused_expressions_1 = __importDefault(require("./no-unused-expressions"));
+const no_unused_private_class_members_1 = __importDefault(require("./no-unused-private-class-members"));
 const no_unused_vars_1 = __importDefault(require("./no-unused-vars"));
 const no_use_before_define_1 = __importDefault(require("./no-use-before-define"));
 const no_useless_constructor_1 = __importDefault(require("./no-useless-constructor"));
@@ -222,6 +223,7 @@ const rules = {
     'no-unsafe-type-assertion': no_unsafe_type_assertion_1.default,
     'no-unsafe-unary-minus': no_unsafe_unary_minus_1.default,
     'no-unused-expressions': no_unused_expressions_1.default,
+    'no-unused-private-class-members': no_unused_private_class_members_1.default,
     'no-unused-vars': no_unused_vars_1.default,
     'no-use-before-define': no_use_before_define_1.default,
     'no-useless-constructor': no_useless_constructor_1.default,

package/dist/rules/no-unused-private-class-members.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export type MessageIds = 'unusedPrivateClassMember';
+declare const _default: ESLintUtils.RuleModule<"unusedPrivateClassMember", [], import("../../rules").ESLintPluginDocs, ESLintUtils.RuleListener>;
+export default _default;

package/dist/rules/no-unused-private-class-members.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const util_1 = require("../util");
+const classScopeAnalyzer_1 = require("../util/class-scope-analyzer/classScopeAnalyzer");
+exports.default = (0, util_1.createRule)({
+    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 = (0, classScopeAnalyzer_1.analyzeClassMemberUsage)(node, utils_1.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 },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/util/class-scope-analyzer/classScopeAnalyzer.d.ts

@@ -0,0 +1,52 @@
+import type { ScopeManager } from '@typescript-eslint/scope-manager';
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { ClassNode, Key, MemberNode } from './types';
+export declare class Member {
+    /**
+     * The node that declares this member
+     */
+    readonly node: MemberNode;
+    /**
+     * The resolved, unique key for this member.
+     */
+    readonly key: Key;
+    /**
+     * The member name, as given in the source code.
+     */
+    readonly name: string;
+    /**
+     * The node that represents the member name in the source code.
+     * Used for reporting errors.
+     */
+    readonly nameNode: TSESTree.Node;
+    /**
+     * The number of writes to this member.
+     */
+    writeCount: number;
+    /**
+     * The number of reads from this member.
+     */
+    readCount: number;
+    private constructor();
+    static create(node: MemberNode): Member | null;
+    isAccessor(): boolean;
+    isHashPrivate(): boolean;
+    isPrivate(): boolean;
+    isStatic(): boolean;
+    isUsed(): boolean;
+}
+export interface ClassScopeResult {
+    /**
+     * The classes name as given in the source code.
+     * If this is `null` then the class is an anonymous class.
+     */
+    readonly className: string | null;
+    /**
+     * The class's members, keyed by their name
+     */
+    readonly members: {
+        readonly instance: Map<Key, Member>;
+        readonly static: Map<Key, Member>;
+    };
+}
+export declare function analyzeClassMemberUsage(program: TSESTree.Program, scopeManager: ScopeManager): ReadonlyMap<ClassNode, ClassScopeResult>;

package/dist/util/class-scope-analyzer/classScopeAnalyzer.js

@@ -0,0 +1,519 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Member = void 0;
+exports.analyzeClassMemberUsage = analyzeClassMemberUsage;
+const scope_manager_1 = require("@typescript-eslint/scope-manager");
+const utils_1 = require("@typescript-eslint/utils");
+const __1 = require("..");
+const extractComputedName_1 = require("./extractComputedName");
+const types_1 = require("./types");
+class Member {
+    /**
+     * The node that declares this member
+     */
+    node;
+    /**
+     * The resolved, unique key for this member.
+     */
+    key;
+    /**
+     * The member name, as given in the source code.
+     */
+    name;
+    /**
+     * The node that represents the member name in the source code.
+     * Used for reporting errors.
+     */
+    nameNode;
+    /**
+     * The number of writes to this member.
+     */
+    writeCount = 0;
+    /**
+     * The number of reads from this member.
+     */
+    readCount = 0;
+    constructor(node, key, name, nameNode) {
+        this.node = node;
+        this.key = key;
+        this.name = name;
+        this.nameNode = nameNode;
+    }
+    static create(node) {
+        const name = (0, extractComputedName_1.extractNameForMember)(node);
+        if (name == null) {
+            return null;
+        }
+        return new Member(node, name.key, name.codeName, name.nameNode);
+    }
+    isAccessor() {
+        if (this.node.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+            this.node.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+            return this.node.kind === 'set' || this.node.kind === 'get';
+        }
+        return (this.node.type === utils_1.AST_NODE_TYPES.AccessorProperty ||
+            this.node.type === utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty);
+    }
+    isHashPrivate() {
+        return ('key' in this.node &&
+            this.node.key.type === utils_1.AST_NODE_TYPES.PrivateIdentifier);
+    }
+    isPrivate() {
+        return this.node.accessibility === 'private';
+    }
+    isStatic() {
+        return this.node.static;
+    }
+    isUsed() {
+        return (this.readCount > 0 ||
+            // any usage of an accessor is considered a usage as accessor can have side effects
+            (this.writeCount > 0 && this.isAccessor()));
+    }
+}
+exports.Member = Member;
+function isWriteOnlyUsage(node, parent) {
+    if (parent.type !== utils_1.AST_NODE_TYPES.AssignmentExpression &&
+        parent.type !== utils_1.AST_NODE_TYPES.ForInStatement &&
+        parent.type !== utils_1.AST_NODE_TYPES.ForOfStatement &&
+        parent.type !== utils_1.AST_NODE_TYPES.AssignmentPattern) {
+        return false;
+    }
+    // If it's on the right then it's a read not a write
+    if (parent.left !== node) {
+        return false;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+        // For any other operator (such as '+=') we still consider it a read operation
+        parent.operator !== '=') {
+        // if the read operation is "discarded" in an empty statement, then it is write only.
+        return parent.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return true;
+}
+function countReference(identifierParent, member) {
+    const identifierGrandparent = (0, __1.nullThrows)(identifierParent.parent, __1.NullThrowsReasons.MissingParent);
+    if (isWriteOnlyUsage(identifierParent, identifierGrandparent)) {
+        member.writeCount += 1;
+        return;
+    }
+    const identifierGreatGrandparent = identifierGrandparent.parent;
+    // A statement which only increments (`this.#x++;`)
+    if (identifierGrandparent.type === utils_1.AST_NODE_TYPES.UpdateExpression &&
+        identifierGreatGrandparent?.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+        member.writeCount += 1;
+        return;
+    }
+    /*
+     * ({ x: this.#usedInDestructuring } = bar);
+     *
+     * But should treat the following as a read:
+     * ({ [this.#x]: a } = foo);
+     */
+    if (identifierGrandparent.type === utils_1.AST_NODE_TYPES.Property &&
+        identifierGreatGrandparent?.type === utils_1.AST_NODE_TYPES.ObjectPattern &&
+        identifierGrandparent.value === identifierParent) {
+        member.writeCount += 1;
+        return;
+    }
+    // [...this.#unusedInRestPattern] = bar;
+    if (identifierGrandparent.type === utils_1.AST_NODE_TYPES.RestElement) {
+        member.writeCount += 1;
+        return;
+    }
+    // [this.#unusedInAssignmentPattern] = bar;
+    if (identifierGrandparent.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        member.writeCount += 1;
+        return;
+    }
+    member.readCount += 1;
+}
+class ThisScope extends scope_manager_1.Visitor {
+    /**
+     * True if the context is considered a static context and so `this` refers to
+     * the class and not an instance (eg a static method or a static block).
+     */
+    isStaticThisContext;
+    /**
+     * The classes directly declared within this class -- for example a class declared within a method.
+     * This does not include grandchild classes.
+     */
+    childScopes = [];
+    /**
+     * The scope manager instance used to resolve variables to improve discovery of usages.
+     */
+    scopeManager;
+    /**
+     * The parent class scope if one exists.
+     */
+    upper;
+    /**
+     * The context of the `this` reference in the current scope.
+     */
+    thisContext;
+    constructor(scopeManager, upper, thisContext, isStaticThisContext) {
+        super({});
+        this.scopeManager = scopeManager;
+        this.upper = upper;
+        this.isStaticThisContext = isStaticThisContext;
+        if (thisContext === 'self') {
+            if (!(this instanceof ClassScope)) {
+                throw new Error('Cannot use `self` unless it is in a ClassScope');
+            }
+            this.thisContext = this;
+        }
+        else if (thisContext === 'none') {
+            this.thisContext = null;
+        }
+        else {
+            this.thisContext = thisContext;
+        }
+    }
+    findNearestScope(node) {
+        let currentScope;
+        let currentNode = node;
+        do {
+            currentScope = this.scopeManager.acquire(currentNode);
+            if (currentNode.parent == null) {
+                break;
+            }
+            currentNode = currentNode.parent;
+        } while (currentScope == null);
+        return currentScope;
+    }
+    findVariableInScope(node, name) {
+        let currentScope = this.findNearestScope(node);
+        let variable = null;
+        while (currentScope != null) {
+            variable = currentScope.set.get(name) ?? null;
+            if (variable != null) {
+                break;
+            }
+            currentScope = currentScope.upper;
+        }
+        return variable;
+    }
+    getObjectClass(node) {
+        switch (node.object.type) {
+            case utils_1.AST_NODE_TYPES.ThisExpression: {
+                if (this.thisContext == null) {
+                    return null;
+                }
+                return {
+                    thisContext: this.thisContext,
+                    type: this.isStaticThisContext ? 'static' : 'instance',
+                };
+            }
+            case utils_1.AST_NODE_TYPES.Identifier: {
+                const thisContext = this.findClassScopeWithName(node.object.name);
+                if (thisContext != null) {
+                    return { thisContext, type: 'static' };
+                }
+                // the following code does some very rudimentary scope analysis to handle some trivial cases
+                const variable = this.findVariableInScope(node, node.object.name);
+                if (variable == null || variable.defs.length === 0) {
+                    return null;
+                }
+                const firstDef = variable.defs[0];
+                switch (firstDef.node.type) {
+                    // detect simple reassignment of `this`
+                    // ```
+                    // class Foo {
+                    //   private prop: number;
+                    //   method(thing: Foo) {
+                    //     const self = this;
+                    //     return self.prop;
+                    //   }
+                    // }
+                    // ```
+                    case utils_1.AST_NODE_TYPES.VariableDeclarator: {
+                        const value = firstDef.node.init;
+                        if (value == null || value.type !== utils_1.AST_NODE_TYPES.ThisExpression) {
+                            return null;
+                        }
+                        if (variable.references.some(ref => ref.isWrite() && ref.init !== true)) {
+                            // variable is assigned to multiple times so we can't be sure that it's still the same class
+                            return null;
+                        }
+                        // we have a case like `const self = this` or `let self = this` that is not reassigned
+                        // so we can safely assume that it's still the same class!
+                        return {
+                            thisContext: this.thisContext,
+                            type: this.isStaticThisContext ? 'static' : 'instance',
+                        };
+                    }
+                    // Look for variables typed as the current class:
+                    // ```
+                    // class Foo {
+                    //   private prop: number;
+                    //   method(thing: Foo) {
+                    //     // this references the private instance member but not via `this` so we can't see it
+                    //     thing.prop = 1;
+                    //   }
+                    // }
+                    // ```
+                    default: {
+                        const typeAnnotation = (() => {
+                            if ('typeAnnotation' in firstDef.name &&
+                                firstDef.name.typeAnnotation != null) {
+                                return firstDef.name.typeAnnotation.typeAnnotation;
+                            }
+                            return null;
+                        })();
+                        if (typeAnnotation == null) {
+                            return null;
+                        }
+                        // Cases like `method(thing: Foo) { ... }`
+                        if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = typeAnnotation.typeName.name;
+                            const typeScope = this.findClassScopeWithName(typeName);
+                            if (typeScope != null) {
+                                return { thisContext: typeScope, type: 'instance' };
+                            }
+                        }
+                        // Cases like `method(thing: typeof Foo) { ... }`
+                        if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeQuery &&
+                            typeAnnotation.exprName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const exprName = typeAnnotation.exprName.name;
+                            const exprScope = this.findClassScopeWithName(exprName);
+                            if (exprScope != null) {
+                                return { thisContext: exprScope, type: 'static' };
+                            }
+                        }
+                    }
+                }
+                return null;
+            }
+            case utils_1.AST_NODE_TYPES.MemberExpression:
+                // TODO - we could probably recurse here to do some more complex analysis and support like `foo.bar.baz` nested references
+                return null;
+            default:
+                return null;
+        }
+    }
+    visitClass(node) {
+        const classScope = new ClassScope(node, this, this.scopeManager);
+        this.childScopes.push(classScope);
+        classScope.visitChildren(node);
+    }
+    visitIntermediate(node) {
+        const intermediateScope = new IntermediateScope(this.scopeManager, this, node);
+        this.childScopes.push(intermediateScope);
+        intermediateScope.visitChildren(node);
+    }
+    /**
+     * Gets the nearest class scope with the given name.
+     */
+    findClassScopeWithName(name) {
+        let currentScope = this;
+        while (currentScope != null) {
+            if (currentScope instanceof ClassScope &&
+                currentScope.className === name) {
+                return currentScope;
+            }
+            currentScope = currentScope.upper;
+        }
+        return null;
+    }
+    /////////////////////
+    // Visit selectors //
+    /////////////////////
+    ClassDeclaration(node) {
+        this.visitClass(node);
+    }
+    ClassExpression(node) {
+        this.visitClass(node);
+    }
+    FunctionDeclaration(node) {
+        this.visitIntermediate(node);
+    }
+    FunctionExpression(node) {
+        this.visitIntermediate(node);
+    }
+    MemberExpression(node) {
+        this.visitChildren(node);
+        if (node.property.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+            // will be handled by the PrivateIdentifier visitor
+            return;
+        }
+        const propertyName = (0, extractComputedName_1.extractNameForMemberExpression)(node);
+        if (propertyName == null) {
+            return;
+        }
+        const objectClassName = this.getObjectClass(node);
+        if (objectClassName == null) {
+            return;
+        }
+        if (objectClassName.thisContext == null) {
+            return;
+        }
+        const members = objectClassName.type === 'instance'
+            ? objectClassName.thisContext.members.instance
+            : objectClassName.thisContext.members.static;
+        const member = members.get(propertyName.key);
+        if (member == null) {
+            return;
+        }
+        countReference(node, member);
+    }
+    PrivateIdentifier(node) {
+        this.visitChildren(node);
+        if ((node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+            node.parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) &&
+            node.parent.key === node) {
+            // ignore the member definition
+            return;
+        }
+        // We can actually be pretty loose with our code here thanks to how private
+        // members are designed.
+        //
+        // 1) classes CANNOT have a static and instance private member with the
+        //    same name, so we don't need to match up static access.
+        // 2) nested classes CANNOT access a private member of their parent class if
+        //    the member has the same name as a private member of the nested class.
+        //
+        // together this means that we can just look for the member upwards until we
+        // find a match and we know that will be the correct match!
+        let currentScope = this;
+        const key = (0, types_1.privateKey)(node);
+        while (currentScope != null) {
+            if (currentScope.thisContext != null) {
+                const member = currentScope.thisContext.members.instance.get(key) ??
+                    currentScope.thisContext.members.static.get(key);
+                if (member != null) {
+                    countReference(node.parent, member);
+                    return;
+                }
+            }
+            currentScope = currentScope.upper;
+        }
+    }
+    StaticBlock(node) {
+        this.visitIntermediate(node);
+    }
+}
+/**
+ * Any other scope that is not a class scope
+ *
+ * When we visit a function declaration/expression the `this` reference is
+ * rebound so it no longer refers to the class.
+ *
+ * This also supports a function's `this` parameter.
+ */
+class IntermediateScope extends ThisScope {
+    constructor(scopeManager, upper, node) {
+        if (node.type === utils_1.AST_NODE_TYPES.Program) {
+            super(scopeManager, upper, 'none', false);
+            return;
+        }
+        if (node.type === utils_1.AST_NODE_TYPES.StaticBlock) {
+            if (upper == null || !(upper instanceof ClassScope)) {
+                throw new Error('Cannot have a static block without an upper ClassScope');
+            }
+            super(scopeManager, upper, upper, true);
+            return;
+        }
+        // method definition
+        if ((node.parent.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+            node.parent.type === utils_1.AST_NODE_TYPES.PropertyDefinition) &&
+            node.parent.value === node) {
+            if (upper == null || !(upper instanceof ClassScope)) {
+                throw new Error('Cannot have a class method/property without an upper ClassScope');
+            }
+            super(scopeManager, upper, upper, node.parent.static);
+            return;
+        }
+        // function with a `this` parameter
+        if (upper != null &&
+            node.params.length > 0 &&
+            node.params[0].type === utils_1.AST_NODE_TYPES.Identifier &&
+            node.params[0].name === 'this') {
+            const thisType = node.params[0].typeAnnotation?.typeAnnotation;
+            if (thisType?.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                thisType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const thisContext = upper.findClassScopeWithName(thisType.typeName.name);
+                if (thisContext != null) {
+                    super(scopeManager, upper, thisContext, false);
+                    return;
+                }
+            }
+        }
+        super(scopeManager, upper, 'none', false);
+    }
+}
+class ClassScope extends ThisScope {
+    className;
+    /**
+     * The class's members, keyed by their name
+     */
+    members = {
+        instance: new Map(),
+        static: new Map(),
+    };
+    /**
+     * The node that declares this class.
+     */
+    theClass;
+    constructor(theClass, upper, scopeManager) {
+        super(scopeManager, upper, 'self', false);
+        this.theClass = theClass;
+        this.className = theClass.id?.name ?? null;
+        for (const memberNode of theClass.body.body) {
+            switch (memberNode.type) {
+                case utils_1.AST_NODE_TYPES.MethodDefinition:
+                    if (memberNode.kind === 'constructor') {
+                        for (const parameter of memberNode.value.params) {
+                            if (parameter.type !== utils_1.AST_NODE_TYPES.TSParameterProperty) {
+                                continue;
+                            }
+                            const member = Member.create(parameter);
+                            if (member == null) {
+                                continue;
+                            }
+                            this.members.instance.set(member.key, member);
+                        }
+                        // break instead of falling through because the constructor is not a "member" we track
+                        break;
+                    }
+                // intentional fallthrough
+                case utils_1.AST_NODE_TYPES.AccessorProperty:
+                case utils_1.AST_NODE_TYPES.PropertyDefinition:
+                case utils_1.AST_NODE_TYPES.TSAbstractAccessorProperty:
+                case utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition:
+                case utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition: {
+                    const member = Member.create(memberNode);
+                    if (member == null) {
+                        continue;
+                    }
+                    if (member.isStatic()) {
+                        this.members.static.set(member.key, member);
+                    }
+                    else {
+                        this.members.instance.set(member.key, member);
+                    }
+                    break;
+                }
+                case utils_1.AST_NODE_TYPES.StaticBlock:
+                    // static blocks declare no members
+                    continue;
+                case utils_1.AST_NODE_TYPES.TSIndexSignature:
+                    // index signatures are type signatures only and are fully computed
+                    continue;
+            }
+        }
+    }
+}
+function analyzeClassMemberUsage(program, scopeManager) {
+    const rootScope = new IntermediateScope(scopeManager, null, program);
+    rootScope.visit(program);
+    return traverseScopes(rootScope);
+}
+function traverseScopes(currentScope, analysisResults = new Map()) {
+    if (currentScope instanceof ClassScope) {
+        analysisResults.set(currentScope.theClass, currentScope);
+    }
+    for (const childScope of currentScope.childScopes) {
+        traverseScopes(childScope, analysisResults);
+    }
+    return analysisResults;
+}

package/dist/util/class-scope-analyzer/extractComputedName.d.ts

@@ -0,0 +1,17 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { Key, MemberNode } from './types';
+export interface ExtractedName {
+    key: Key;
+    codeName: string;
+    nameNode: TSESTree.Node;
+}
+/**
+ * Extracts the string name for a member.
+ * @returns `null` if the name cannot be extracted due to it being computed.
+ */
+export declare function extractNameForMember(node: MemberNode): ExtractedName | null;
+/**
+ * Extracts the string property name for a member.
+ * @returns `null` if the name cannot be extracted due to it being a computed.
+ */
+export declare function extractNameForMemberExpression(node: TSESTree.MemberExpression): ExtractedName | null;

package/dist/util/class-scope-analyzer/extractComputedName.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractNameForMember = extractNameForMember;
+exports.extractNameForMemberExpression = extractNameForMemberExpression;
+const utils_1 = require("@typescript-eslint/utils");
+const types_1 = require("./types");
+function extractComputedName(computedName) {
+    if (computedName.type === utils_1.AST_NODE_TYPES.Literal) {
+        const name = computedName.value?.toString() ?? 'null';
+        return {
+            codeName: name,
+            key: (0, types_1.publicKey)(name),
+            nameNode: computedName,
+        };
+    }
+    if (computedName.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        computedName.expressions.length === 0) {
+        const name = computedName.quasis[0].value.raw;
+        return {
+            codeName: name,
+            key: (0, types_1.publicKey)(name),
+            nameNode: computedName,
+        };
+    }
+    return null;
+}
+function extractNonComputedName(nonComputedName) {
+    const name = nonComputedName.name;
+    if (nonComputedName.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+        return {
+            codeName: `#${name}`,
+            key: (0, types_1.privateKey)(nonComputedName),
+            nameNode: nonComputedName,
+        };
+    }
+    return {
+        codeName: name,
+        key: (0, types_1.publicKey)(name),
+        nameNode: nonComputedName,
+    };
+}
+/**
+ * Extracts the string name for a member.
+ * @returns `null` if the name cannot be extracted due to it being computed.
+ */
+function extractNameForMember(node) {
+    if (node.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
+        switch (node.parameter.type) {
+            case utils_1.AST_NODE_TYPES.ArrayPattern:
+            case utils_1.AST_NODE_TYPES.ObjectPattern:
+            case utils_1.AST_NODE_TYPES.RestElement:
+                // Nonsensical properties -- see https://github.com/typescript-eslint/typescript-eslint/issues/11708
+                return null;
+            case utils_1.AST_NODE_TYPES.AssignmentPattern:
+                if (node.parameter.left.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return null;
+                }
+                return extractNonComputedName(node.parameter.left);
+            case utils_1.AST_NODE_TYPES.Identifier:
+                return extractNonComputedName(node.parameter);
+        }
+    }
+    if (node.computed) {
+        return extractComputedName(node.key);
+    }
+    if (node.key.type === utils_1.AST_NODE_TYPES.Literal) {
+        return extractComputedName(node.key);
+    }
+    return extractNonComputedName(node.key);
+}
+/**
+ * Extracts the string property name for a member.
+ * @returns `null` if the name cannot be extracted due to it being a computed.
+ */
+function extractNameForMemberExpression(node) {
+    if (node.computed) {
+        return extractComputedName(node.property);
+    }
+    return extractNonComputedName(node.property);
+}

package/dist/util/class-scope-analyzer/types.d.ts

@@ -0,0 +1,12 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export type ClassNode = TSESTree.ClassDeclaration | TSESTree.ClassExpression;
+export type MemberNode = TSESTree.AccessorProperty | TSESTree.MethodDefinition | TSESTree.PropertyDefinition | TSESTree.TSAbstractAccessorProperty | TSESTree.TSAbstractMethodDefinition | TSESTree.TSAbstractPropertyDefinition | TSESTree.TSParameterProperty;
+export type PrivateKey = string & {
+    __brand: 'private-key';
+};
+export type PublicKey = string & {
+    __brand: 'public-key';
+};
+export type Key = PrivateKey | PublicKey;
+export declare function publicKey(name: string): PublicKey;
+export declare function privateKey(node: TSESTree.PrivateIdentifier): PrivateKey;

package/dist/util/class-scope-analyzer/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicKey = publicKey;
+exports.privateKey = privateKey;
+function publicKey(name) {
+    return name;
+}
+function privateKey(node) {
+    return `#private@@${node.name}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.46.5-alpha.0",
+  "version": "8.46.5-alpha.2",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.46.5-alpha.0",
-    "@typescript-eslint/type-utils": "8.46.5-alpha.0",
-    "@typescript-eslint/utils": "8.46.5-alpha.0",
-    "@typescript-eslint/visitor-keys": "8.46.5-alpha.0",
+    "@typescript-eslint/scope-manager": "8.46.5-alpha.2",
+    "@typescript-eslint/type-utils": "8.46.5-alpha.2",
+    "@typescript-eslint/utils": "8.46.5-alpha.2",
+    "@typescript-eslint/visitor-keys": "8.46.5-alpha.2",
     "graphemer": "^1.4.0",
     "ignore": "^7.0.0",
     "natural-compare": "^1.4.0",
@@ -71,8 +71,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.46.5-alpha.0",
-    "@typescript-eslint/rule-tester": "8.46.5-alpha.0",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.46.5-alpha.2",
+    "@typescript-eslint/rule-tester": "8.46.5-alpha.2",
     "@vitest/coverage-v8": "^3.1.3",
     "ajv": "^6.12.6",
     "cross-fetch": "*",
@@ -92,7 +92,7 @@
     "vitest": "^3.1.3"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.46.5-alpha.0",
+    "@typescript-eslint/parser": "^8.46.5-alpha.2",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },