@typescript-eslint/eslint-plugin 8.52.1-alpha.9 → 8.53.1

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

@@ -148,6 +148,7 @@ declare const _default: {
         'no-return-await': "off";
         '@typescript-eslint/return-await': "error";
         '@typescript-eslint/strict-boolean-expressions': "error";
+        '@typescript-eslint/strict-void-return': "error";
         '@typescript-eslint/switch-exhaustiveness-check': "error";
         '@typescript-eslint/triple-slash-reference': "error";
         '@typescript-eslint/unbound-method': "error";

package/dist/configs/eslintrc/all.js

@@ -155,6 +155,7 @@ module.exports = {
         'no-return-await': 'off',
         '@typescript-eslint/return-await': 'error',
         '@typescript-eslint/strict-boolean-expressions': 'error',
+        '@typescript-eslint/strict-void-return': 'error',
         '@typescript-eslint/switch-exhaustiveness-check': 'error',
         '@typescript-eslint/triple-slash-reference': 'error',
         '@typescript-eslint/unbound-method': 'error',

package/dist/configs/eslintrc/disable-type-checked.d.ts

@@ -62,6 +62,7 @@ declare const _default: {
         '@typescript-eslint/restrict-template-expressions': "off";
         '@typescript-eslint/return-await': "off";
         '@typescript-eslint/strict-boolean-expressions': "off";
+        '@typescript-eslint/strict-void-return': "off";
         '@typescript-eslint/switch-exhaustiveness-check': "off";
         '@typescript-eslint/unbound-method': "off";
         '@typescript-eslint/use-unknown-in-catch-callback-variable': "off";

package/dist/configs/eslintrc/disable-type-checked.js

@@ -65,6 +65,7 @@ module.exports = {
         '@typescript-eslint/restrict-template-expressions': 'off',
         '@typescript-eslint/return-await': 'off',
         '@typescript-eslint/strict-boolean-expressions': 'off',
+        '@typescript-eslint/strict-void-return': 'off',
         '@typescript-eslint/switch-exhaustiveness-check': 'off',
         '@typescript-eslint/unbound-method': 'off',
         '@typescript-eslint/use-unknown-in-catch-callback-variable': 'off',

package/dist/configs/flat/all.js

@@ -168,6 +168,7 @@ exports.default = (plugin, parser) => [
             'no-return-await': 'off',
             '@typescript-eslint/return-await': 'error',
             '@typescript-eslint/strict-boolean-expressions': 'error',
+            '@typescript-eslint/strict-void-return': 'error',
             '@typescript-eslint/switch-exhaustiveness-check': 'error',
             '@typescript-eslint/triple-slash-reference': 'error',
             '@typescript-eslint/unbound-method': 'error',

package/dist/configs/flat/disable-type-checked.js

@@ -70,6 +70,7 @@ exports.default = (_plugin, _parser) => ({
         '@typescript-eslint/restrict-template-expressions': 'off',
         '@typescript-eslint/return-await': 'off',
         '@typescript-eslint/strict-boolean-expressions': 'off',
+        '@typescript-eslint/strict-void-return': 'off',
         '@typescript-eslint/switch-exhaustiveness-check': 'off',
         '@typescript-eslint/unbound-method': 'off',
         '@typescript-eslint/use-unknown-in-catch-callback-variable': 'off',

package/dist/index.d.ts

@@ -150,6 +150,7 @@ declare const _default: {
                 'no-return-await': "off";
                 '@typescript-eslint/return-await': "error";
                 '@typescript-eslint/strict-boolean-expressions': "error";
+                '@typescript-eslint/strict-void-return': "error";
                 '@typescript-eslint/switch-exhaustiveness-check': "error";
                 '@typescript-eslint/triple-slash-reference': "error";
                 '@typescript-eslint/unbound-method': "error";
@@ -228,6 +229,7 @@ declare const _default: {
                 '@typescript-eslint/restrict-template-expressions': "off";
                 '@typescript-eslint/return-await': "off";
                 '@typescript-eslint/strict-boolean-expressions': "off";
+                '@typescript-eslint/strict-void-return': "off";
                 '@typescript-eslint/switch-exhaustiveness-check': "off";
                 '@typescript-eslint/unbound-method': "off";
                 '@typescript-eslint/use-unknown-in-catch-callback-variable': "off";
@@ -1096,6 +1098,11 @@ declare const _default: {
         'strict-boolean-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/strict-boolean-expressions").MessageId, import("./rules/strict-boolean-expressions").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn", [{
+            allowReturnAny?: boolean;
+        }], import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'switch-exhaustiveness-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./rules/switch-exhaustiveness-check").MessageIds, import("./rules/switch-exhaustiveness-check").Options, import("../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/dist/raw-plugin.d.ts

@@ -172,6 +172,7 @@ declare const _default: {
                     'no-return-await': "off";
                     '@typescript-eslint/return-await': "error";
                     '@typescript-eslint/strict-boolean-expressions': "error";
+                    '@typescript-eslint/strict-void-return': "error";
                     '@typescript-eslint/switch-exhaustiveness-check': "error";
                     '@typescript-eslint/triple-slash-reference': "error";
                     '@typescript-eslint/unbound-method': "error";
@@ -250,6 +251,7 @@ declare const _default: {
                     '@typescript-eslint/restrict-template-expressions': "off";
                     '@typescript-eslint/return-await': "off";
                     '@typescript-eslint/strict-boolean-expressions': "off";
+                    '@typescript-eslint/strict-void-return': "off";
                     '@typescript-eslint/switch-exhaustiveness-check': "off";
                     '@typescript-eslint/unbound-method': "off";
                     '@typescript-eslint/use-unknown-in-catch-callback-variable': "off";
@@ -1119,6 +1121,11 @@ declare const _default: {
             'strict-boolean-expressions': TSESLint.RuleModule<import("./rules/strict-boolean-expressions").MessageId, import("./rules/strict-boolean-expressions").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };
+            'strict-void-return': TSESLint.RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn", [{
+                allowReturnAny?: boolean;
+            }], import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
+                name: string;
+            };
             'switch-exhaustiveness-check': TSESLint.RuleModule<import("./rules/switch-exhaustiveness-check").MessageIds, import("./rules/switch-exhaustiveness-check").Options, import("../rules").ESLintPluginDocs, TSESLint.RuleListener> & {
                 name: string;
             };

package/dist/rules/consistent-indexed-object-style.js

@@ -114,7 +114,8 @@ exports.default = (0, util_1.createRule)({
                             .map(p => context.sourceCode.getText(p))
                             .join(', ')}>`;
                     }
-                    checkMembers(node.body.body, node, node.id, `type ${node.id.name}${genericTypes} = `, ';', !node.extends.length);
+                    checkMembers(node.body.body, node, node.id, `type ${node.id.name}${genericTypes} = `, ';', !node.extends.length &&
+                        node.parent.type !== utils_1.AST_NODE_TYPES.ExportDefaultDeclaration);
                 },
                 TSMappedType(node) {
                     const key = node.key;

package/dist/rules/index.d.ts

@@ -419,6 +419,11 @@ declare const rules: {
     'strict-boolean-expressions': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./strict-boolean-expressions").MessageId, import("./strict-boolean-expressions").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };
+    'strict-void-return': import("@typescript-eslint/utils/ts-eslint").RuleModule<"asyncFunc" | "nonVoidFunc" | "nonVoidReturn", [{
+        allowReturnAny?: boolean;
+    }], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        name: string;
+    };
     'switch-exhaustiveness-check': import("@typescript-eslint/utils/ts-eslint").RuleModule<import("./switch-exhaustiveness-check").MessageIds, import("./switch-exhaustiveness-check").Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
         name: string;
     };

package/dist/rules/index.js

@@ -129,6 +129,7 @@ const restrict_template_expressions_1 = __importDefault(require("./restrict-temp
 const return_await_1 = __importDefault(require("./return-await"));
 const sort_type_constituents_1 = __importDefault(require("./sort-type-constituents"));
 const strict_boolean_expressions_1 = __importDefault(require("./strict-boolean-expressions"));
+const strict_void_return_1 = __importDefault(require("./strict-void-return"));
 const switch_exhaustiveness_check_1 = __importDefault(require("./switch-exhaustiveness-check"));
 const triple_slash_reference_1 = __importDefault(require("./triple-slash-reference"));
 const typedef_1 = __importDefault(require("./typedef"));
@@ -263,6 +264,7 @@ const rules = {
     'return-await': return_await_1.default,
     'sort-type-constituents': sort_type_constituents_1.default,
     'strict-boolean-expressions': strict_boolean_expressions_1.default,
+    'strict-void-return': strict_void_return_1.default,
     'switch-exhaustiveness-check': switch_exhaustiveness_check_1.default,
     'triple-slash-reference': triple_slash_reference_1.default,
     typedef: typedef_1.default,

package/dist/rules/no-unused-vars.d.ts

@@ -1,5 +1,5 @@
 import { TSESLint } from '@typescript-eslint/utils';
-export type MessageIds = 'unusedVar' | 'usedIgnoredVar' | 'usedOnlyAsType';
+export type MessageIds = 'removeUnusedImportDeclaration' | 'removeUnusedVar' | 'unusedVar' | 'usedIgnoredVar' | 'usedOnlyAsType';
 export type Options = [
     'all' | 'local' | {
         args?: 'after-used' | 'all' | 'none';
@@ -7,6 +7,9 @@ export type Options = [
         caughtErrors?: 'all' | 'none';
         caughtErrorsIgnorePattern?: string;
         destructuredArrayIgnorePattern?: string;
+        enableAutofixRemoval?: {
+            imports?: boolean;
+        };
         ignoreClassWithStaticInitBlock?: boolean;
         ignoreRestSiblings?: boolean;
         ignoreUsingDeclarations?: boolean;

package/dist/rules/no-unused-vars.js

@@ -4,6 +4,45 @@ const scope_manager_1 = require("@typescript-eslint/scope-manager");
 const utils_1 = require("@typescript-eslint/utils");
 const util_1 = require("../util");
 const referenceContainsTypeQuery_1 = require("../util/referenceContainsTypeQuery");
+// this is a superset of DefinitionType which defines sub-types for better granularity
+var VariableType;
+(function (VariableType) {
+    // New sub-types
+    VariableType[VariableType["ArrayDestructure"] = 0] = "ArrayDestructure";
+    // DefinitionType
+    VariableType[VariableType["CatchClause"] = 1] = "CatchClause";
+    VariableType[VariableType["ClassName"] = 2] = "ClassName";
+    VariableType[VariableType["FunctionName"] = 3] = "FunctionName";
+    VariableType[VariableType["ImportBinding"] = 4] = "ImportBinding";
+    VariableType[VariableType["ImplicitGlobalVariable"] = 5] = "ImplicitGlobalVariable";
+    VariableType[VariableType["Parameter"] = 6] = "Parameter";
+    VariableType[VariableType["TSEnumMember"] = 7] = "TSEnumMember";
+    VariableType[VariableType["TSEnumName"] = 8] = "TSEnumName";
+    VariableType[VariableType["TSModuleName"] = 9] = "TSModuleName";
+    VariableType[VariableType["Type"] = 10] = "Type";
+    VariableType[VariableType["Variable"] = 11] = "Variable";
+})(VariableType || (VariableType = {}));
+const isCommaToken = {
+    predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === ',',
+    tokenChar: ',',
+};
+const isLeftCurlyToken = {
+    predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '{',
+    tokenChar: '{',
+};
+const isRightCurlyToken = {
+    predicate: (token) => token.type === utils_1.AST_TOKEN_TYPES.Punctuator && token.value === '}',
+    tokenChar: '}',
+};
+function assertToken({ predicate, tokenChar }, token) {
+    if (token == null) {
+        throw new Error(`Expected a valid "${tokenChar}" token, but found no token`);
+    }
+    if (!predicate(token)) {
+        throw new Error(`Expected a valid "${tokenChar}" token, but got "${token.value}" instead`);
+    }
+    return token;
+}
 exports.default = (0, util_1.createRule)({
     name: 'no-unused-vars',
     meta: {
@@ -13,7 +52,11 @@ exports.default = (0, util_1.createRule)({
             extendsBaseRule: true,
             recommended: 'recommended',
         },
+        fixable: 'code',
+        hasSuggestions: true,
         messages: {
+            removeUnusedImportDeclaration: 'Remove unused import declaration.',
+            removeUnusedVar: 'Remove unused variable "{{varName}}".',
             unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
             usedIgnoredVar: "'{{varName}}' is marked as ignored but is used{{additional}}.",
             usedOnlyAsType: "'{{varName}}' is {{action}} but only used as a type{{additional}}.",
@@ -52,6 +95,17 @@ exports.default = (0, util_1.createRule)({
                                 type: 'string',
                                 description: 'Regular expressions of destructured array variable names to not check for usage.',
                             },
+                            enableAutofixRemoval: {
+                                type: 'object',
+                                additionalProperties: false,
+                                description: 'Configurable automatic fixes for different types of unused variables.',
+                                properties: {
+                                    imports: {
+                                        type: 'boolean',
+                                        description: 'Whether to enable automatic removal of unused imports.',
+                                    },
+                                },
+                            },
                             ignoreClassWithStaticInitBlock: {
                                 type: 'boolean',
                                 description: 'Whether to ignore classes with at least one static initialization block.',
@@ -86,10 +140,130 @@ exports.default = (0, util_1.createRule)({
     defaultOptions: [{}],
     create(context, [firstOption]) {
         const MODULE_DECL_CACHE = new Map();
+        const reportedUnusedVariables = new Set();
+        function areAllSpecifiersUnused(decl) {
+            return context.sourceCode.getDeclaredVariables(decl).every(variable => {
+                return reportedUnusedVariables.has(variable);
+            });
+        }
+        const report = (unusedVar, opts) => {
+            reportedUnusedVariables.add(unusedVar);
+            const writeReferences = unusedVar.references.filter(ref => ref.isWrite() &&
+                ref.from.variableScope === unusedVar.scope.variableScope);
+            const id = writeReferences.length
+                ? writeReferences[writeReferences.length - 1].identifier
+                : unusedVar.identifiers[0];
+            const { start } = id.loc;
+            const idLength = id.name.length;
+            const loc = {
+                start,
+                end: {
+                    column: start.column + idLength,
+                    line: start.line,
+                },
+            };
+            const fixer = (() => {
+                const { messageId, fix, useAutofix } = (() => {
+                    if (unusedVar.defs.length !== 1) {
+                        // If there's multiple definitions then we'd have to clean them all
+                        // up! That's complicated and messy so for now let's just ignore it.
+                        return {};
+                    }
+                    const { type, def } = defToVariableType(unusedVar.defs[0]);
+                    switch (type) {
+                        case VariableType.ArrayDestructure:
+                            // TODO(bradzacher) -- this would be really easy to implement and
+                            // is side-effect free!
+                            return {};
+                        case VariableType.CatchClause:
+                            // TODO(bradzacher) -- this would be really easy to implement and
+                            // is side-effect free!
+                            return {};
+                        case VariableType.ClassName:
+                            // This would be easy to implement -- but classes can have
+                            // side-effects in static initializers / static blocks. So it's
+                            // dangerous to ever auto-fix remove them.
+                            //
+                            // Perhaps as an always-suggestion fixer...?
+                            return {};
+                        case VariableType.FunctionName:
+                            // TODO(bradzacher) -- this would be really easy to implement and
+                            // is side-effect free!
+                            return {};
+                        case VariableType.ImportBinding:
+                            return {
+                                ...getImportFixer(def),
+                                useAutofix: options.enableAutofixRemoval.imports,
+                            };
+                        case VariableType.ImplicitGlobalVariable:
+                            // We don't report these via this code path, so no fixer is possible
+                            return {};
+                        case VariableType.Parameter:
+                            // This is easy to implement -- but we cannot implement it cos it
+                            // changes the signature of the function which in turn might
+                            // introduce type errors in consumers.
+                            //
+                            // Also parameters can have default values which might have
+                            // side-effects.
+                            //
+                            // Perhaps as an always-suggestion fixer...?
+                            return {};
+                        case VariableType.TSEnumMember:
+                            // We don't report unused enum members so no fixer is ever possible
+                            return {};
+                        case VariableType.TSEnumName:
+                            // TODO(bradzacher) -- this would be really easy to implement and
+                            // is side-effect free!
+                            return {};
+                        case VariableType.TSModuleName:
+                            // This is easy to implement -- but TS namespaces are eagerly
+                            // initialized -- meaning that they might have side-effects in
+                            // the body. So it's dangerous to ever auto-fix remove them.
+                            //
+                            // Perhaps as an always-suggestion fixer...?
+                            return {};
+                        case VariableType.Type:
+                            // TODO(bradzacher) -- this would be really easy to implement and
+                            // is side-effect free!
+                            return {};
+                        case VariableType.Variable:
+                            // TODO(bradzacher) -- this would be really easy to implement
+                            return {};
+                    }
+                })();
+                if (!fix) {
+                    return {};
+                }
+                if (useAutofix) {
+                    return { fix };
+                }
+                const data = {
+                    varName: unusedVar.name,
+                };
+                return {
+                    suggest: [
+                        {
+                            messageId: messageId ?? 'removeUnusedVar',
+                            data,
+                            fix,
+                        },
+                    ],
+                };
+            })();
+            context.report({
+                ...opts,
+                ...fixer,
+                loc,
+                node: id,
+            });
+        };
         const options = (() => {
             const options = {
                 args: 'after-used',
                 caughtErrors: 'all',
+                enableAutofixRemoval: {
+                    imports: false,
+                },
                 ignoreClassWithStaticInitBlock: false,
                 ignoreRestSiblings: false,
                 ignoreUsingDeclarations: false,
@@ -126,9 +300,171 @@ exports.default = (0, util_1.createRule)({
                 if (firstOption.destructuredArrayIgnorePattern) {
                     options.destructuredArrayIgnorePattern = new RegExp(firstOption.destructuredArrayIgnorePattern, 'u');
                 }
+                if (firstOption.enableAutofixRemoval) {
+                    // eslint-disable-next-line unicorn/no-lonely-if -- will add more cases later
+                    if (firstOption.enableAutofixRemoval.imports != null) {
+                        options.enableAutofixRemoval.imports =
+                            firstOption.enableAutofixRemoval.imports;
+                    }
+                }
             }
             return options;
         })();
+        function getImportFixer(def) {
+            switch (def.node.type) {
+                case utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration:
+                    // import equals declarations can only have one binding -- so we can
+                    // just remove entire import declaration
+                    return {
+                        messageId: 'removeUnusedImportDeclaration',
+                        fix: fixer => fixer.remove(def.node),
+                    };
+                case utils_1.AST_NODE_TYPES.ImportDefaultSpecifier: {
+                    const importDecl = def.node.parent;
+                    if (importDecl.specifiers.length === 1 ||
+                        areAllSpecifiersUnused(importDecl)) {
+                        // all specifiers are unused -- so we can just remove entire import
+                        // declaration
+                        return {
+                            messageId: 'removeUnusedImportDeclaration',
+                            fix: fixer => fixer.remove(importDecl),
+                        };
+                    }
+                    // in this branch we know the following things:
+                    // 1) there is at least one specifier that is used
+                    // 2) the default specifier is unused
+                    //
+                    // by process of elimination we can deduce that there is at least one
+                    // named specifier that is used
+                    //
+                    // i.e. the code must be import Unused, { Used, ... } from 'module';
+                    //
+                    // there's one or more unused named specifiers, so we must remove the
+                    // default specifier in isolation including the trailing comma.
+                    //
+                    //     import Unused, { Used, ... } from 'module';
+                    //            ^^^^^^^ remove this
+                    //
+                    // NOTE: we could also remove the spaces between the comma and the
+                    // opening curly brace -- but this does risk removing comments. To be
+                    // safe we'll be conservative for now
+                    //
+                    // TODO(bradzacher) -- consider removing the extra space whilst also
+                    //                     preserving comments.
+                    return {
+                        messageId: 'removeUnusedVar',
+                        fix: fixer => {
+                            const comma = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(def.node), util_1.NullThrowsReasons.MissingToken(',', 'import specifier'));
+                            assertToken(isCommaToken, comma);
+                            return fixer.removeRange([
+                                Math.min(def.node.range[0], comma.range[0]),
+                                Math.max(def.node.range[1], comma.range[1]),
+                            ]);
+                        },
+                    };
+                }
+                case utils_1.AST_NODE_TYPES.ImportSpecifier: {
+                    // guaranteed to NOT be in an export statement as we're inspecting an
+                    // import
+                    const importDecl = def.node.parent;
+                    if (importDecl.specifiers.length === 1 ||
+                        areAllSpecifiersUnused(importDecl)) {
+                        // all specifiers are unused -- so we can just remove entire import
+                        // declaration
+                        return {
+                            messageId: 'removeUnusedImportDeclaration',
+                            fix: fixer => fixer.remove(importDecl),
+                        };
+                    }
+                    return {
+                        messageId: 'removeUnusedVar',
+                        fix: fixer => {
+                            const usedNamedSpecifiers = context.sourceCode
+                                .getDeclaredVariables(importDecl)
+                                .map(variable => {
+                                if (reportedUnusedVariables.has(variable)) {
+                                    return null;
+                                }
+                                const specifier = variable.defs[0].node;
+                                if (specifier.type !== utils_1.AST_NODE_TYPES.ImportSpecifier) {
+                                    return null;
+                                }
+                                return specifier;
+                            })
+                                .filter(v => v != null);
+                            if (usedNamedSpecifiers.length === 0) {
+                                // in this branch we know the following things:
+                                // 1) there is at least one specifier that is used
+                                // 2) all named specifiers are unused
+                                //
+                                // by process of elimination we can deduce that there is a
+                                // default specifier and it is the only used specifier
+                                //
+                                // i.e. the code must be import Used, { Unused, ... } from
+                                //     'module';
+                                //
+                                // So we can just remove the entire curly content and the comma
+                                // before, eg import Used, { Unused, ... } from 'module';
+                                // ^^^^^^^^^^^^^^^^^ remove this
+                                const leftCurly = assertToken(isLeftCurlyToken, context.sourceCode.getFirstToken(importDecl, isLeftCurlyToken.predicate));
+                                const leftToken = assertToken(isCommaToken, context.sourceCode.getTokenBefore(leftCurly));
+                                const rightToken = assertToken(isRightCurlyToken, context.sourceCode.getFirstToken(importDecl, isRightCurlyToken.predicate));
+                                return fixer.removeRange([
+                                    leftToken.range[0],
+                                    rightToken.range[1],
+                                ]);
+                            }
+                            // in this branch we know there is at least one used named
+                            // specifier which means we have to remove each unused specifier
+                            // in isolation.
+                            //
+                            // there's 3 possible cases to care about: import { Unused,
+                            //    Used... } from 'module'; import { ...Used, Unused } from
+                            //    'module'; import { ...Used, Unused, } from 'module';
+                            //
+                            // Note that because of the above usedNamedSpecifiers check we
+                            // know that we don't have one of these cases: import { Unused }
+                            // from 'module'; import { Unused, Unused... } from 'module';
+                            // import { ...Unused, Unused, } from 'module';
+                            //
+                            // The result is that we know that there _must_ be a comma that
+                            // needs cleaning up
+                            //
+                            // try to remove the leading comma first as it leads to a nicer
+                            // fix output in most cases
+                            //
+                            // leading preferred: import { Used, Unused, Used } from 'module';
+                            //   ^^^^^^^^ remove import { Used, Used } from 'module';
+                            //
+                            // trailing preferred: import { Used, Unused, Used } from
+                            //   'module'; ^^^^^^^ remove import { Used,  Used } from
+                            //   'module'; ^^ ugly double space
+                            //
+                            // But we need to still fallback to the trailing comma for cases
+                            // where the unused specifier is the first in the import eg:
+                            // import { Unused, Used } from 'module';
+                            const maybeComma = context.sourceCode.getTokenBefore(def.node);
+                            const comma = maybeComma && isCommaToken.predicate(maybeComma)
+                                ? maybeComma
+                                : assertToken(isCommaToken, context.sourceCode.getTokenAfter(def.node));
+                            return fixer.removeRange([
+                                Math.min(def.node.range[0], comma.range[0]),
+                                Math.max(def.node.range[1], comma.range[1]),
+                            ]);
+                        },
+                    };
+                }
+                case utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier: {
+                    // namespace specifiers cannot be used with any other specifier -- so
+                    // we can just remove entire import declaration
+                    const importDecl = def.node.parent;
+                    return {
+                        messageId: 'removeUnusedImportDeclaration',
+                        fix: fixer => fixer.remove(importDecl),
+                    };
+                }
+            }
+        }
         /**
          * Determines what variable type a def is.
          * @param def the declaration to check
@@ -146,15 +482,31 @@ exports.default = (0, util_1.createRule)({
              */
             if (options.destructuredArrayIgnorePattern &&
                 def.name.parent.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
-                return 'array-destructure';
+                return { type: VariableType.ArrayDestructure, def };
             }
             switch (def.type) {
                 case scope_manager_1.DefinitionType.CatchClause:
-                    return 'catch-clause';
+                    return { type: VariableType.CatchClause, def };
+                case scope_manager_1.DefinitionType.ClassName:
+                    return { type: VariableType.ClassName, def };
+                case scope_manager_1.DefinitionType.FunctionName:
+                    return { type: VariableType.FunctionName, def };
+                case scope_manager_1.DefinitionType.ImplicitGlobalVariable:
+                    return { type: VariableType.ImplicitGlobalVariable, def };
+                case scope_manager_1.DefinitionType.ImportBinding:
+                    return { type: VariableType.ImportBinding, def };
                 case scope_manager_1.DefinitionType.Parameter:
-                    return 'parameter';
-                default:
-                    return 'variable';
+                    return { type: VariableType.Parameter, def };
+                case scope_manager_1.DefinitionType.TSEnumName:
+                    return { type: VariableType.TSEnumName, def };
+                case scope_manager_1.DefinitionType.TSEnumMember:
+                    return { type: VariableType.TSEnumMember, def };
+                case scope_manager_1.DefinitionType.TSModuleName:
+                    return { type: VariableType.TSModuleName, def };
+                case scope_manager_1.DefinitionType.Type:
+                    return { type: VariableType.Type, def };
+                case scope_manager_1.DefinitionType.Variable:
+                    return { type: VariableType.Variable, def };
             }
         }
         /**
@@ -166,22 +518,22 @@ exports.default = (0, util_1.createRule)({
          */
         function getVariableDescription(variableType) {
             switch (variableType) {
-                case 'array-destructure':
+                case VariableType.ArrayDestructure:
                     return {
                         pattern: options.destructuredArrayIgnorePattern?.toString(),
                         variableDescription: 'elements of array destructuring',
                     };
-                case 'catch-clause':
+                case VariableType.CatchClause:
                     return {
                         pattern: options.caughtErrorsIgnorePattern?.toString(),
                         variableDescription: 'caught errors',
                     };
-                case 'parameter':
+                case VariableType.Parameter:
                     return {
                         pattern: options.argsIgnorePattern?.toString(),
                         variableDescription: 'args',
                     };
-                case 'variable':
+                default:
                     return {
                         pattern: options.varsIgnorePattern?.toString(),
                         variableDescription: 'vars',
@@ -198,7 +550,7 @@ exports.default = (0, util_1.createRule)({
             const def = unusedVar.defs.at(0);
             let additionalMessageData = '';
             if (def) {
-                const { pattern, variableDescription } = getVariableDescription(defToVariableType(def));
+                const { pattern, variableDescription } = getVariableDescription(defToVariableType(def).type);
                 if (pattern && variableDescription) {
                     additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
                 }
@@ -219,7 +571,7 @@ exports.default = (0, util_1.createRule)({
             const def = unusedVar.defs.at(0);
             let additionalMessageData = '';
             if (def) {
-                const { pattern, variableDescription } = getVariableDescription(defToVariableType(def));
+                const { pattern, variableDescription } = getVariableDescription(defToVariableType(def).type);
                 if (pattern && variableDescription) {
                     additionalMessageData = `. Allowed unused ${variableDescription} must match ${pattern}`;
                 }
@@ -318,10 +670,9 @@ exports.default = (0, util_1.createRule)({
                     def.name.type === utils_1.AST_NODE_TYPES.Identifier &&
                     options.destructuredArrayIgnorePattern?.test(def.name.name)) {
                     if (options.reportUsedIgnorePattern && used) {
-                        context.report({
-                            node: def.name,
+                        report(variable, {
                             messageId: 'usedIgnoredVar',
-                            data: getUsedIgnoredMessageData(variable, 'array-destructure'),
+                            data: getUsedIgnoredMessageData(variable, VariableType.ArrayDestructure),
                         });
                     }
                     continue;
@@ -341,10 +692,9 @@ exports.default = (0, util_1.createRule)({
                     if (def.name.type === utils_1.AST_NODE_TYPES.Identifier &&
                         options.caughtErrorsIgnorePattern?.test(def.name.name)) {
                         if (options.reportUsedIgnorePattern && used) {
-                            context.report({
-                                node: def.name,
+                            report(variable, {
                                 messageId: 'usedIgnoredVar',
-                                data: getUsedIgnoredMessageData(variable, 'catch-clause'),
+                                data: getUsedIgnoredMessageData(variable, VariableType.CatchClause),
                             });
                         }
                         continue;
@@ -359,10 +709,9 @@ exports.default = (0, util_1.createRule)({
                     if (def.name.type === utils_1.AST_NODE_TYPES.Identifier &&
                         options.argsIgnorePattern?.test(def.name.name)) {
                         if (options.reportUsedIgnorePattern && used) {
-                            context.report({
-                                node: def.name,
+                            report(variable, {
                                 messageId: 'usedIgnoredVar',
-                                data: getUsedIgnoredMessageData(variable, 'parameter'),
+                                data: getUsedIgnoredMessageData(variable, VariableType.Parameter),
                             });
                         }
                         continue;
@@ -382,10 +731,9 @@ exports.default = (0, util_1.createRule)({
                         /* enum members are always marked as 'used' by `collectVariables`, but in reality they may be used or
                            unused. either way, don't complain about their naming. */
                         def.type !== utils_1.TSESLint.Scope.DefinitionType.TSEnumMember) {
-                        context.report({
-                            node: def.name,
+                        report(variable, {
                             messageId: 'usedIgnoredVar',
-                            data: getUsedIgnoredMessageData(variable, 'variable'),
+                            data: getUsedIgnoredMessageData(variable, VariableType.Variable),
                         });
                     }
                     continue;
@@ -455,28 +803,13 @@ exports.default = (0, util_1.createRule)({
                     // Report the first declaration.
                     if (unusedVar.defs.length > 0) {
                         const usedOnlyAsType = unusedVar.references.some(ref => (0, referenceContainsTypeQuery_1.referenceContainsTypeQuery)(ref.identifier));
+                        const messageId = usedOnlyAsType ? 'usedOnlyAsType' : 'unusedVar';
                         const isImportUsedOnlyAsType = usedOnlyAsType &&
                             unusedVar.defs.some(def => def.type === scope_manager_1.DefinitionType.ImportBinding);
                         if (isImportUsedOnlyAsType) {
                             continue;
                         }
-                        const writeReferences = unusedVar.references.filter(ref => ref.isWrite() &&
-                            ref.from.variableScope === unusedVar.scope.variableScope);
-                        const id = writeReferences.length
-                            ? writeReferences[writeReferences.length - 1].identifier
-                            : unusedVar.identifiers[0];
-                        const messageId = usedOnlyAsType ? 'usedOnlyAsType' : 'unusedVar';
-                        const { start } = id.loc;
-                        const idLength = id.name.length;
-                        const loc = {
-                            start,
-                            end: {
-                                column: start.column + idLength,
-                                line: start.line,
-                            },
-                        };
-                        context.report({
-                            loc,
+                        report(unusedVar, {
                             messageId,
                             data: unusedVar.references.some(ref => ref.isWrite())
                                 ? getAssignedMessageData(unusedVar)

package/dist/rules/no-useless-default-assignment.js

@@ -111,6 +111,11 @@ exports.default = (0, util_1.createRule)({
                         const params = signatures[0].getParameters();
                         if (paramIndex < params.length) {
                             const paramSymbol = params[paramIndex];
+                            if (paramSymbol.valueDeclaration &&
+                                ts.isParameter(paramSymbol.valueDeclaration) &&
+                                paramSymbol.valueDeclaration.dotDotDotToken != null) {
+                                return;
+                            }
                             if ((paramSymbol.flags & ts.SymbolFlags.Optional) === 0) {
                                 const paramType = checker.getTypeOfSymbol(paramSymbol);
                                 if (!canBeUndefined(paramType)) {

package/dist/rules/strict-void-return.d.ts

@@ -0,0 +1,10 @@
+type Options = [
+    {
+        allowReturnAny?: boolean;
+    }
+];
+type MessageId = `asyncFunc` | `nonVoidFunc` | `nonVoidReturn`;
+declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageId, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/rules/strict-void-return.js

@@ -0,0 +1,356 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'strict-void-return',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow passing a value-returning function in a position accepting a void function',
+            requiresTypeChecking: true,
+        },
+        messages: {
+            asyncFunc: 'Async function used in a context where a void function is expected.',
+            nonVoidFunc: 'Value-returning function used in a context where a void function is expected.',
+            nonVoidReturn: 'Value returned in a context where a void return is expected.',
+        },
+        schema: [
+            {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    allowReturnAny: {
+                        type: 'boolean',
+                        description: 'Whether to allow functions returning `any` to be used in place expecting a `void` function.',
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowReturnAny: false,
+        },
+    ],
+    create(context, [options]) {
+        const sourceCode = context.sourceCode;
+        const parserServices = util.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        return {
+            ArrayExpression: (node) => {
+                for (const elemNode of node.elements) {
+                    if (elemNode != null &&
+                        elemNode.type !== utils_1.AST_NODE_TYPES.SpreadElement) {
+                        checkExpressionNode(elemNode);
+                    }
+                }
+            },
+            ArrowFunctionExpression: (node) => {
+                if (node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                    checkExpressionNode(node.body);
+                }
+            },
+            AssignmentExpression: (node) => {
+                checkExpressionNode(node.right); // should ignore operators like `+=` or `-=` automatically
+            },
+            'CallExpression, NewExpression': checkFunctionCallNode,
+            JSXAttribute: (node) => {
+                if (node.value?.type === utils_1.AST_NODE_TYPES.JSXExpressionContainer &&
+                    node.value.expression.type !== utils_1.AST_NODE_TYPES.JSXEmptyExpression) {
+                    checkExpressionNode(node.value.expression);
+                }
+            },
+            MethodDefinition: checkClassMethodNode,
+            ObjectExpression: (node) => {
+                for (const propNode of node.properties) {
+                    if (propNode.type !== utils_1.AST_NODE_TYPES.SpreadElement) {
+                        checkObjectPropertyNode(propNode);
+                    }
+                }
+            },
+            PropertyDefinition: checkClassPropertyNode,
+            ReturnStatement: (node) => {
+                if (node.argument != null) {
+                    checkExpressionNode(node.argument);
+                }
+            },
+            VariableDeclarator: (node) => {
+                if (node.init != null) {
+                    checkExpressionNode(node.init);
+                }
+            },
+        };
+        function isVoidReturningFunctionType(type) {
+            const returnTypes = tsutils
+                .getCallSignaturesOfType(type)
+                .flatMap(signature => tsutils.unionConstituents(signature.getReturnType()));
+            return (returnTypes.length > 0 &&
+                returnTypes.every(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.Void)));
+        }
+        /**
+         * Finds errors in any expression node.
+         *
+         * Compares the type of the node against the contextual (expected) type.
+         *
+         * @returns `true` if the expected type was void function.
+         */
+        function checkExpressionNode(node) {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const expectedType = checker.getContextualType(tsNode);
+            if (expectedType != null && isVoidReturningFunctionType(expectedType)) {
+                reportIfNonVoidFunction(node);
+                return true;
+            }
+            return false;
+        }
+        /**
+         * Finds errors in function calls.
+         *
+         * When checking arguments, we also manually figure out the argument types
+         * by iterating over all the function signatures.
+         * Thanks to this, we can find arguments like `(() => void) | (() => any)`
+         * and treat them as void too.
+         * This is done to also support checking functions like `addEventListener`
+         * which have overloads where one callback returns any.
+         *
+         * Implementation mostly based on no-misused-promises,
+         * which does this to find `(() => void) | (() => NotThenable)`
+         * and report them too.
+         */
+        function checkFunctionCallNode(callNode) {
+            const callTsNode = parserServices.esTreeNodeToTSNodeMap.get(callNode);
+            const funcType = checker.getTypeAtLocation(callTsNode.expression);
+            const funcSignatures = tsutils
+                .unionConstituents(funcType)
+                .flatMap(type => ts.isCallExpression(callTsNode)
+                ? type.getCallSignatures()
+                : type.getConstructSignatures());
+            for (const [argIdx, argNode] of callNode.arguments.entries()) {
+                if (argNode.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    continue;
+                }
+                // Check against the contextual type first
+                if (checkExpressionNode(argNode)) {
+                    continue;
+                }
+                // Check against the types from all of the call signatures
+                const argExpectedReturnTypes = funcSignatures
+                    .map(s => s.parameters[argIdx])
+                    .filter(Boolean)
+                    .map(param => checker.getTypeOfSymbolAtLocation(param, callTsNode.expression))
+                    .flatMap(paramType => tsutils.unionConstituents(paramType))
+                    .flatMap(paramType => paramType.getCallSignatures())
+                    .map(paramSignature => paramSignature.getReturnType());
+                if (
+                // At least one return type is void
+                argExpectedReturnTypes.some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.Void)) &&
+                    // The rest are nullish or any
+                    argExpectedReturnTypes.every(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.VoidLike |
+                        ts.TypeFlags.Undefined |
+                        ts.TypeFlags.Null |
+                        ts.TypeFlags.Any |
+                        ts.TypeFlags.Never))) {
+                    // We treat this argument as void even though it might be technically any.
+                    reportIfNonVoidFunction(argNode);
+                }
+            }
+        }
+        /**
+         * Finds errors in an object property.
+         *
+         * Object properties require different logic
+         * when the property is a method shorthand.
+         */
+        function checkObjectPropertyNode(propNode) {
+            const valueNode = propNode.value;
+            const propTsNode = parserServices.esTreeNodeToTSNodeMap.get(propNode);
+            if (propTsNode.kind === ts.SyntaxKind.MethodDeclaration) {
+                // Object property is a method shorthand.
+                if (propTsNode.name.kind === ts.SyntaxKind.ComputedPropertyName) {
+                    // Don't check object methods with computed name.
+                    return;
+                }
+                const objTsNode = propTsNode.parent;
+                const objType = checker.getContextualType(objTsNode);
+                if (objType == null) {
+                    // Expected object type is unknown.
+                    return;
+                }
+                const propSymbol = checker.getPropertyOfType(objType, propTsNode.name.text);
+                if (propSymbol == null) {
+                    // Expected object type is known, but it doesn't have this method.
+                    return;
+                }
+                const propExpectedType = checker.getTypeOfSymbolAtLocation(propSymbol, propTsNode);
+                if (isVoidReturningFunctionType(propExpectedType)) {
+                    reportIfNonVoidFunction(valueNode);
+                }
+                return;
+            }
+            // Object property is a regular property.
+            checkExpressionNode(valueNode);
+        }
+        /**
+         * Finds errors in a class property.
+         *
+         * In addition to the regular check against the contextual type,
+         * we also check against the base class property (when the class extends another class)
+         * and the implemented interfaces (when the class implements an interface).
+         */
+        function checkClassPropertyNode(propNode) {
+            if (propNode.value == null) {
+                return;
+            }
+            // Check in comparison to the base types.
+            for (const { baseMemberType } of util.getBaseTypesOfClassMember(parserServices, propNode)) {
+                if (isVoidReturningFunctionType(baseMemberType)) {
+                    reportIfNonVoidFunction(propNode.value);
+                    return; // Report at most one error.
+                }
+            }
+            // Check in comparison to the contextual type.
+            checkExpressionNode(propNode.value);
+        }
+        /**
+         * Finds errors in a class method.
+         *
+         * We check against the base class method (when the class extends another class)
+         * and the implemented interfaces (when the class implements an interface).
+         */
+        function checkClassMethodNode(methodNode) {
+            if (methodNode.value.type === utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
+                return;
+            }
+            // Check in comparison to the base types.
+            for (const { baseMemberType } of util.getBaseTypesOfClassMember(parserServices, methodNode)) {
+                if (isVoidReturningFunctionType(baseMemberType)) {
+                    reportIfNonVoidFunction(methodNode.value);
+                    return; // Report at most one error.
+                }
+            }
+        }
+        /**
+         * Reports an error if the provided node is not allowed in a void function context.
+         */
+        function reportIfNonVoidFunction(funcNode) {
+            const allowedReturnType = ts.TypeFlags.Void |
+                ts.TypeFlags.Never |
+                ts.TypeFlags.Undefined |
+                (options.allowReturnAny ? ts.TypeFlags.Any : 0);
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(funcNode);
+            const actualType = checker.getApparentType(checker.getTypeAtLocation(tsNode));
+            if (tsutils
+                .getCallSignaturesOfType(actualType)
+                .map(signature => signature.getReturnType())
+                .flatMap(returnType => tsutils.unionConstituents(returnType))
+                .every(type => tsutils.isTypeFlagSet(type, allowedReturnType))) {
+                // The function is already void.
+                return;
+            }
+            if (funcNode.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                funcNode.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+                // The provided function is not a function literal.
+                // Report a generic error.
+                return context.report({
+                    node: funcNode,
+                    messageId: `nonVoidFunc`,
+                });
+            }
+            // The provided function is a function literal.
+            if (funcNode.generator) {
+                // The provided function is a generator function.
+                // Generator functions are not allowed.
+                return context.report({
+                    loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+                    messageId: `nonVoidFunc`,
+                });
+            }
+            if (funcNode.async) {
+                // The provided function is an async function.
+                // Async functions aren't allowed.
+                return context.report({
+                    loc: util.getFunctionHeadLoc(funcNode, sourceCode),
+                    messageId: `asyncFunc`,
+                });
+            }
+            if (funcNode.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+                // The provided function is an arrow function shorthand without braces.
+                return context.report({
+                    node: funcNode.body,
+                    messageId: `nonVoidReturn`,
+                });
+            }
+            // The function is a regular or arrow function with a block body.
+            // Check return type annotation.
+            if (funcNode.returnType != null) {
+                // The provided function has an explicit return type annotation.
+                const typeAnnotationNode = funcNode.returnType.typeAnnotation;
+                if (typeAnnotationNode.type !== utils_1.AST_NODE_TYPES.TSVoidKeyword) {
+                    // The explicit return type is not `void`.
+                    return context.report({
+                        node: typeAnnotationNode,
+                        messageId: `nonVoidFunc`,
+                    });
+                }
+            }
+            // Iterate over all function's return statements.
+            for (const statement of util.walkStatements(funcNode.body.body)) {
+                if (statement.type !== utils_1.AST_NODE_TYPES.ReturnStatement ||
+                    statement.argument == null) {
+                    // We only care about return statements with a value.
+                    continue;
+                }
+                const returnType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(statement.argument));
+                if (tsutils.isTypeFlagSet(returnType, allowedReturnType)) {
+                    // Only visit return statements with invalid type.
+                    continue;
+                }
+                // This return statement causes the non-void return type.
+                const returnKeyword = util.nullThrows(sourceCode.getFirstToken(statement, {
+                    filter: token => token.value === 'return',
+                }), util.NullThrowsReasons.MissingToken('return keyword', statement.type));
+                context.report({
+                    node: returnKeyword,
+                    messageId: `nonVoidReturn`,
+                });
+            }
+            // No invalid returns found. The function is allowed.
+        }
+    },
+});

package/dist/util/getBaseTypesOfClassMember.d.ts

@@ -0,0 +1,11 @@
+import type { TSESTree, ParserServicesWithTypeInformation } from '@typescript-eslint/utils';
+import type * as ts from 'typescript';
+/**
+ * Given a member of a class which extends another class or implements an interface,
+ * yields the corresponding member type for each of the base class/interfaces.
+ */
+export declare function getBaseTypesOfClassMember(services: ParserServicesWithTypeInformation, memberNode: TSESTree.MethodDefinition | TSESTree.PropertyDefinition): Generator<{
+    baseType: ts.Type;
+    baseMemberType: ts.Type;
+    heritageToken: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword;
+}>;

package/dist/util/getBaseTypesOfClassMember.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaseTypesOfClassMember = getBaseTypesOfClassMember;
+/**
+ * Given a member of a class which extends another class or implements an interface,
+ * yields the corresponding member type for each of the base class/interfaces.
+ */
+function* getBaseTypesOfClassMember(services, memberNode) {
+    const memberTsNode = services.esTreeNodeToTSNodeMap.get(memberNode);
+    if (memberTsNode.name == null) {
+        return;
+    }
+    const checker = services.program.getTypeChecker();
+    const memberSymbol = checker.getSymbolAtLocation(memberTsNode.name);
+    if (memberSymbol == null) {
+        return;
+    }
+    const classNode = memberTsNode.parent;
+    for (const clauseNode of classNode.heritageClauses ?? []) {
+        for (const baseTypeNode of clauseNode.types) {
+            const baseType = checker.getTypeAtLocation(baseTypeNode);
+            const baseMemberSymbol = checker.getPropertyOfType(baseType, memberSymbol.name);
+            if (baseMemberSymbol == null) {
+                continue;
+            }
+            const baseMemberType = checker.getTypeOfSymbolAtLocation(baseMemberSymbol, memberTsNode);
+            const heritageToken = clauseNode.token;
+            yield { baseMemberType, baseType, heritageToken };
+        }
+    }
+}

package/dist/util/index.d.ts

@@ -3,6 +3,7 @@ export * from './astUtils';
 export * from './baseTypeUtils';
 export * from './collectUnusedVariables';
 export * from './createRule';
+export * from './getBaseTypesOfClassMember';
 export * from './getFixOrSuggest';
 export * from './getFunctionHeadLoc';
 export * from './getOperatorPrecedence';
@@ -29,6 +30,7 @@ export * from './getValueOfLiteralType';
 export * from './isHigherPrecedenceThanAwait';
 export * from './skipChainExpression';
 export * from './truthinessUtils';
+export * from './walkStatements';
 export * from '@typescript-eslint/type-utils';
 export declare const applyDefault: typeof ESLintUtils.applyDefault, deepMerge: typeof ESLintUtils.deepMerge, getParserServices: typeof ESLintUtils.getParserServices, isObjectNotArray: typeof ESLintUtils.isObjectNotArray, nullThrows: typeof ESLintUtils.nullThrows, NullThrowsReasons: {
     readonly MissingParent: "Expected node to have a parent.";

package/dist/util/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./astUtils"), exports);
 __exportStar(require("./baseTypeUtils"), exports);
 __exportStar(require("./collectUnusedVariables"), exports);
 __exportStar(require("./createRule"), exports);
+__exportStar(require("./getBaseTypesOfClassMember"), exports);
 __exportStar(require("./getFixOrSuggest"), exports);
 __exportStar(require("./getFunctionHeadLoc"), exports);
 __exportStar(require("./getOperatorPrecedence"), exports);
@@ -46,6 +47,7 @@ __exportStar(require("./getValueOfLiteralType"), exports);
 __exportStar(require("./isHigherPrecedenceThanAwait"), exports);
 __exportStar(require("./skipChainExpression"), exports);
 __exportStar(require("./truthinessUtils"), exports);
+__exportStar(require("./walkStatements"), exports);
 // this is done for convenience - saves migrating all of the old rules
 __exportStar(require("@typescript-eslint/type-utils"), exports);
 exports.applyDefault = utils_1.ESLintUtils.applyDefault, exports.deepMerge = utils_1.ESLintUtils.deepMerge, exports.getParserServices = utils_1.ESLintUtils.getParserServices, exports.isObjectNotArray = utils_1.ESLintUtils.isObjectNotArray, exports.nullThrows = utils_1.ESLintUtils.nullThrows, exports.NullThrowsReasons = utils_1.ESLintUtils.NullThrowsReasons;

package/dist/util/walkStatements.d.ts

@@ -0,0 +1,7 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+/**
+ * Yields all statement nodes in a block, including nested blocks.
+ *
+ * You can use it to find all return statements in a function body.
+ */
+export declare function walkStatements(body: readonly TSESTree.Statement[]): Generator<TSESTree.Statement>;

package/dist/util/walkStatements.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkStatements = walkStatements;
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * Yields all statement nodes in a block, including nested blocks.
+ *
+ * You can use it to find all return statements in a function body.
+ */
+function* walkStatements(body) {
+    for (const statement of body) {
+        switch (statement.type) {
+            case utils_1.AST_NODE_TYPES.BlockStatement: {
+                yield* walkStatements(statement.body);
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.SwitchStatement: {
+                for (const switchCase of statement.cases) {
+                    yield* walkStatements(switchCase.consequent);
+                }
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.IfStatement: {
+                yield* walkStatements([statement.consequent]);
+                if (statement.alternate) {
+                    yield* walkStatements([statement.alternate]);
+                }
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.WhileStatement:
+            case utils_1.AST_NODE_TYPES.DoWhileStatement:
+            case utils_1.AST_NODE_TYPES.ForStatement:
+            case utils_1.AST_NODE_TYPES.ForInStatement:
+            case utils_1.AST_NODE_TYPES.ForOfStatement:
+            case utils_1.AST_NODE_TYPES.WithStatement:
+            case utils_1.AST_NODE_TYPES.LabeledStatement: {
+                yield* walkStatements([statement.body]);
+                continue;
+            }
+            case utils_1.AST_NODE_TYPES.TryStatement: {
+                yield* walkStatements([statement.block]);
+                if (statement.handler) {
+                    yield* walkStatements([statement.handler.body]);
+                }
+                if (statement.finalizer) {
+                    yield* walkStatements([statement.finalizer]);
+                }
+                continue;
+            }
+            default: {
+                yield statement;
+                continue;
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.52.1-alpha.9",
+  "version": "8.53.1",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.52.1-alpha.9",
-    "@typescript-eslint/type-utils": "8.52.1-alpha.9",
-    "@typescript-eslint/utils": "8.52.1-alpha.9",
-    "@typescript-eslint/visitor-keys": "8.52.1-alpha.9",
+    "@typescript-eslint/scope-manager": "8.53.1",
+    "@typescript-eslint/type-utils": "8.53.1",
+    "@typescript-eslint/utils": "8.53.1",
+    "@typescript-eslint/visitor-keys": "8.53.1",
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.4.0"
@@ -70,8 +70,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.52.1-alpha.9",
-    "@typescript-eslint/rule-tester": "8.52.1-alpha.9",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.53.1",
+    "@typescript-eslint/rule-tester": "8.53.1",
     "@vitest/coverage-v8": "^3.2.4",
     "ajv": "^6.12.6",
     "eslint": "*",
@@ -90,7 +90,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.52.1-alpha.9",
+    "@typescript-eslint/parser": "^8.53.1",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },