@typescript-eslint/eslint-plugin 8.52.1-alpha.1 → 8.52.1-alpha.11

package/dist/rules/no-unsafe-call.d.ts

@@ -1,4 +1,4 @@
-export type MessageIds = 'unsafeCall' | 'unsafeCallThis' | 'unsafeNew' | 'unsafeTemplateTag';
+export type MessageIds = 'errorCall' | 'errorCallThis' | 'errorNew' | 'errorTemplateTag' | 'unsafeCall' | 'unsafeCallThis' | 'unsafeNew' | 'unsafeTemplateTag';
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, [], import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/no-unsafe-call.js

@@ -45,13 +45,17 @@ exports.default = (0, util_1.createRule)({
             requiresTypeChecking: true,
         },
         messages: {
-            unsafeCall: 'Unsafe call of a(n) {{type}} typed value.',
+            errorCall: 'Unsafe call of a type that could not be resolved.',
+            errorCallThis: 'Unsafe call of a `this` type that could not be resolved.',
+            errorNew: 'Unsafe construction of a type that could not be resolved.',
+            errorTemplateTag: 'Unsafe use of a template tag whose type could not be resolved.',
+            unsafeCall: 'Unsafe call of {{type}} typed value.',
             unsafeCallThis: [
-                'Unsafe call of a(n) {{type}} typed value. `this` is typed as {{type}}.',
+                'Unsafe call of {{type}} typed value. `this` is typed as {{type}}.',
                 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
             ].join('\n'),
-            unsafeNew: 'Unsafe construction of a(n) {{type}} typed value.',
-            unsafeTemplateTag: 'Unsafe use of a(n) {{type}} typed template tag.',
+            unsafeNew: 'Unsafe construction of {{type}} typed value.',
+            unsafeTemplateTag: 'Unsafe use of {{type}} typed template tag.',
         },
         schema: [],
     },
@@ -60,7 +64,7 @@ exports.default = (0, util_1.createRule)({
         const services = (0, util_1.getParserServices)(context);
         const compilerOptions = services.program.getCompilerOptions();
         const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(compilerOptions, 'noImplicitThis');
-        function checkCall(node, reportingNode, messageId) {
+        function checkCall(node, reportingNode, unsafeMessageId, errorMessageId) {
             const type = (0, util_1.getConstrainedTypeAtLocation)(services, node);
             if ((0, util_1.isTypeAnyType)(type)) {
                 if (!isNoImplicitThis) {
@@ -68,15 +72,16 @@ exports.default = (0, util_1.createRule)({
                     const thisExpression = (0, util_1.getThisExpression)(node);
                     if (thisExpression &&
                         (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) {
-                        messageId = 'unsafeCallThis';
+                        unsafeMessageId = 'unsafeCallThis';
+                        errorMessageId = 'errorCallThis';
                     }
                 }
                 const isErrorType = tsutils.isIntrinsicErrorType(type);
                 context.report({
                     node: reportingNode,
-                    messageId,
+                    messageId: isErrorType ? errorMessageId : unsafeMessageId,
                     data: {
-                        type: isErrorType ? '`error` type' : '`any`',
+                        type: 'an `any`',
                     },
                 });
                 return;
@@ -98,7 +103,7 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 const callSignatures = type.getCallSignatures();
-                if (messageId === 'unsafeNew') {
+                if (unsafeMessageId === 'unsafeNew') {
                     if (callSignatures.some(signature => !tsutils.isIntrinsicVoidType(signature.getReturnType()))) {
                         return;
                     }
@@ -108,9 +113,9 @@ exports.default = (0, util_1.createRule)({
                 }
                 context.report({
                     node: reportingNode,
-                    messageId,
+                    messageId: unsafeMessageId,
                     data: {
-                        type: '`Function`',
+                        type: 'a `Function`',
                     },
                 });
                 return;
@@ -118,13 +123,13 @@ exports.default = (0, util_1.createRule)({
         }
         return {
             'CallExpression > *.callee'(node) {
-                checkCall(node, node, 'unsafeCall');
+                checkCall(node, node, 'unsafeCall', 'errorCall');
             },
             NewExpression(node) {
-                checkCall(node.callee, node, 'unsafeNew');
+                checkCall(node.callee, node, 'unsafeNew', 'errorNew');
             },
             'TaggedTemplateExpression > *.tag'(node) {
-                checkCall(node, node, 'unsafeTemplateTag');
+                checkCall(node, node, 'unsafeTemplateTag', 'errorTemplateTag');
             },
         };
     },

package/dist/rules/no-unsafe-member-access.d.ts

@@ -3,7 +3,7 @@ export type Options = [
         allowOptionalChaining?: boolean;
     }
 ];
-export type MessageIds = 'unsafeComputedMemberAccess' | 'unsafeMemberExpression' | 'unsafeThisMemberExpression';
+export type MessageIds = 'errorComputedMemberAccess' | 'errorMemberExpression' | 'errorThisMemberExpression' | 'unsafeComputedMemberAccess' | 'unsafeMemberExpression' | 'unsafeThisMemberExpression';
 declare const _default: import("@typescript-eslint/utils/ts-eslint").RuleModule<MessageIds, Options, import("../../rules").ESLintPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
     name: string;
 };

package/dist/rules/no-unsafe-member-access.js

@@ -42,10 +42,6 @@ var State;
     State[State["Safe"] = 2] = "Safe";
     State[State["Chained"] = 3] = "Chained";
 })(State || (State = {}));
-function createDataType(type) {
-    const isErrorType = tsutils.isIntrinsicErrorType(type);
-    return isErrorType ? '`error` typed' : '`any`';
-}
 exports.default = (0, util_1.createRule)({
     name: 'no-unsafe-member-access',
     meta: {
@@ -56,8 +52,14 @@ exports.default = (0, util_1.createRule)({
             requiresTypeChecking: true,
         },
         messages: {
-            unsafeComputedMemberAccess: 'Computed name {{property}} resolves to an {{type}} value.',
-            unsafeMemberExpression: 'Unsafe member access {{property}} on an {{type}} value.',
+            errorComputedMemberAccess: 'The type of computed name {{property}} cannot be resolved.',
+            errorMemberExpression: 'Unsafe member access {{property}} on a type that cannot be resolved.',
+            errorThisMemberExpression: [
+                'Unsafe member access {{property}}. The type of `this` cannot be resolved.',
+                'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
+            ].join('\n'),
+            unsafeComputedMemberAccess: 'Computed name {{property}} resolves to an `any` value.',
+            unsafeMemberExpression: 'Unsafe member access {{property}} on an `any` value.',
             unsafeThisMemberExpression: [
                 'Unsafe member access {{property}} on an `any` value. `this` is typed as `any`.',
                 'You can try to fix this by turning on the `noImplicitThis` compiler option, or adding a `this` parameter to the function.',
@@ -116,20 +118,28 @@ exports.default = (0, util_1.createRule)({
             stateCache.set(node, state);
             if (state === State.Unsafe) {
                 const propertyName = context.sourceCode.getText(node.property);
-                let messageId = 'unsafeMemberExpression';
+                let messageId;
                 if (!isNoImplicitThis) {
                     // `this.foo` or `this.foo[bar]`
                     const thisExpression = (0, util_1.getThisExpression)(node);
-                    if (thisExpression &&
-                        (0, util_1.isTypeAnyType)((0, util_1.getConstrainedTypeAtLocation)(services, thisExpression))) {
-                        messageId = 'unsafeThisMemberExpression';
+                    if (thisExpression) {
+                        const thisType = (0, util_1.getConstrainedTypeAtLocation)(services, thisExpression);
+                        if ((0, util_1.isTypeAnyType)(thisType)) {
+                            messageId = tsutils.isIntrinsicErrorType(thisType)
+                                ? 'errorThisMemberExpression'
+                                : 'unsafeThisMemberExpression';
+                        }
                     }
                 }
+                if (!messageId) {
+                    messageId = tsutils.isIntrinsicErrorType(type)
+                        ? 'errorMemberExpression'
+                        : 'unsafeMemberExpression';
+                }
                 context.report({
                     node: node.property,
                     messageId,
                     data: {
-                        type: createDataType(type),
                         property: node.computed ? `[${propertyName}]` : `.${propertyName}`,
                     },
                 });
@@ -159,9 +169,10 @@ exports.default = (0, util_1.createRule)({
                     const propertyName = context.sourceCode.getText(node);
                     context.report({
                         node,
-                        messageId: 'unsafeComputedMemberAccess',
+                        messageId: tsutils.isIntrinsicErrorType(type)
+                            ? 'errorComputedMemberAccess'
+                            : 'unsafeComputedMemberAccess',
                         data: {
-                            type: createDataType(type),
                             property: `[${propertyName}]`,
                         },
                     });

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.52.1-alpha.1",
+  "version": "8.52.1-alpha.11",
   "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.1",
-    "@typescript-eslint/type-utils": "8.52.1-alpha.1",
-    "@typescript-eslint/utils": "8.52.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.52.1-alpha.1",
+    "@typescript-eslint/scope-manager": "8.52.1-alpha.11",
+    "@typescript-eslint/type-utils": "8.52.1-alpha.11",
+    "@typescript-eslint/utils": "8.52.1-alpha.11",
+    "@typescript-eslint/visitor-keys": "8.52.1-alpha.11",
     "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.1",
-    "@typescript-eslint/rule-tester": "8.52.1-alpha.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.52.1-alpha.11",
+    "@typescript-eslint/rule-tester": "8.52.1-alpha.11",
     "@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.1",
+    "@typescript-eslint/parser": "^8.52.1-alpha.11",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },