typescript-eslint · nayounsang · May 23, 2025 · May 23, 2025 · May 24, 2025 · Jun 3, 2025
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
@@ -15,6 +15,7 @@
 import {
   collectVariables,
   createRule,
+  getFixOrSuggest,
   getNameLocationInGlobalDirectiveComment,
   isDefinitionFile,
   isFunction,
@@ -23,7 +24,11 @@
 } from '../util';
 import { referenceContainsTypeQuery } from '../util/referenceContainsTypeQuery';
 
-export type MessageIds = 'unusedVar' | 'usedIgnoredVar' | 'usedOnlyAsType';
+export type MessageIds =
+  | 'unusedVar'
+  | 'unusedVarSuggestion'
+  | 'usedIgnoredVar'
+  | 'usedOnlyAsType';
 export type Options = [
   | 'all'
   | 'local'
@@ -38,6 +43,9 @@
       reportUsedIgnorePattern?: boolean;
       vars?: 'all' | 'local';
       varsIgnorePattern?: string;
+      enableAutofixRemoval?: {
+        imports: boolean;
+      };
     },
 ];
 
@@ -52,6 +60,9 @@
   reportUsedIgnorePattern: boolean;
   vars: 'all' | 'local';
   varsIgnorePattern?: RegExp;
+  enableAutofixRemoval?: {
+    imports: boolean;
+  };
 }
 
 type VariableType =
@@ -74,8 +85,13 @@
       extendsBaseRule: true,
       recommended: 'recommended',
     },
+    fixable: 'code',
+    // If generate suggest dynamically, disable the eslint rule.
+    // eslint-disable-next-line eslint-plugin/require-meta-has-suggestions
+    hasSuggestions: true,
     messages: {
       unusedVar: "'{{varName}}' is {{action}} but never used{{additional}}.",
+      unusedVarSuggestion: 'Remove unused variable.',
       usedIgnoredVar:
         "'{{varName}}' is marked as ignored but is used{{additional}}.",
       usedOnlyAsType:
@@ -117,6 +133,16 @@
                 description:
                   'Regular expressions of destructured array variable names to not check for usage.',
               },
+              enableAutofixRemoval: {
+                type: 'object',
+                properties: {
+                  imports: {
+                    type: 'boolean',
+                    description:
+                      'Whether to enable autofix for removing unused imports.',
+                  },
+                },
+              },
               ignoreClassWithStaticInitBlock: {
                 type: 'boolean',
                 description:
@@ -208,6 +234,10 @@
             'u',
           );
         }
+
+        if (firstOption.enableAutofixRemoval) {
+          options.enableAutofixRemoval = firstOption.enableAutofixRemoval;
+        }
       }
 
       return options;
@@ -641,6 +671,63 @@
       // collect
       'Program:exit'(programNode): void {
         const unusedVars = collectUnusedVariables();
+        /**
+         * metadata of import declaration include unused specifiers
+         */
+        interface UnusedDecl {
+          /**
+           * Ranges of all unused default & named specifiers
+           */
+          unusedNodeRanges: TSESLint.AST.Range[];
+          /**
+           * Range of named imports include braces
+           */
+          namedRange?: TSESLint.AST.Range;
+          /**
+           * Range of import declaration
+           */
+          declRange: TSESLint.AST.Range;
+        }
+
+        // Structuring unused specifiers for each decl
+        const unusedDecl = new Map<string, UnusedDecl>();
+        for (const unusedVar of unusedVars) {
+          const def = unusedVar.defs.find(
+            d => d.type === DefinitionType.ImportBinding,
+          );
+          if (!def) {
+            continue;
+          }
+          const node = def.node;
+          const decl = node.parent;
+          if (decl.type !== AST_NODE_TYPES.ImportDeclaration) {
+            continue;
+          }
+          const mapKey = decl.range.toString();
+          const afterNodeToken = context.sourceCode.getTokenAfter(node);
+          const beforeNodeToken = context.sourceCode.getTokenBefore(node);
+
+          const prevValue = unusedDecl.get(mapKey);
+          // get range of { A, B, C, ... , D }
+          const namedRange = prevValue?.namedRange ?? [0, 0];
+          if (beforeNodeToken?.value === '{') {
+            namedRange[0] = beforeNodeToken.range[0];
+          }
+          if (afterNodeToken?.value === '}') {
+            namedRange[1] = afterNodeToken.range[1];
+          }
+
+          unusedDecl.set(mapKey, {
+            declRange: decl.range,
+            namedRange: namedRange.every(v => v === 0)
+              ? prevValue?.namedRange
+              : namedRange,
+            unusedNodeRanges: [
+              ...(prevValue?.unusedNodeRanges ?? []),
+              node.range,
+            ],
+          });
+        }
 
         for (const unusedVar of unusedVars) {
           // Report the first declaration.
@@ -681,12 +768,88 @@
               },
             };
 
+            const fixer: TSESLint.ReportFixFunction = fixer => {
+              // Find the import statement
+              const def = unusedVar.defs.find(
+                d => d.type === DefinitionType.ImportBinding,
+              );
+              if (!def) {
+                return null;
+              }
+
+              const source = context.sourceCode;
+              const node = def.node;
+              const decl = node.parent;
+              if (decl.type !== AST_NODE_TYPES.ImportDeclaration) {
+                // decl.type is Program, import foo = require('bar');
+                return fixer.remove(node);
+              }
+
+              const afterNodeToken = source.getTokenAfter(node);
+              const beforeNodeToken = source.getTokenBefore(node);
+              const prevBeforeNodeToken = beforeNodeToken
+                ? source.getTokenBefore(beforeNodeToken)
+                : null;
+
+              const declInfo = unusedDecl.get(decl.range.toString());
+
+              // Remove import declaration if no used specifiers are left, import unused from 'a';
+              if (
+                declInfo &&
+                decl.specifiers.length === declInfo.unusedNodeRanges.length
+              ) {
+                return fixer.removeRange(declInfo.declRange);
+              }
+
+              // case: remove braces, import used, { unused } from 'a';
+              const restNamed = decl.specifiers.filter(
+                s => s.type === AST_NODE_TYPES.ImportSpecifier,
+              );
+              if (
+                declInfo?.namedRange &&
+                restNamed.length === declInfo.unusedNodeRanges.length &&
+                prevBeforeNodeToken?.value === ','
+              ) {
+                return fixer.removeRange([
+                  prevBeforeNodeToken.range[0],
+                  declInfo.namedRange[1],
+                ]);
+              }
+
+              // case: Remove comma after node, import { unused, used } from 'a';
+              if (afterNodeToken?.value === ',') {
+                return fixer.removeRange([
+                  node.range[0],
+                  afterNodeToken.range[1],
+                ]);
+              }
+
+              // case: Remove comma before node, import { used, unused } from 'a';
+              if (beforeNodeToken?.value === ',') {
+                return fixer.removeRange([
+                  beforeNodeToken.range[0],
+                  node.range[1],
+                ]);
+              }
+
+              return null;
+            };
+
             context.report({
               loc,
               messageId,
               data: unusedVar.references.some(ref => ref.isWrite())
                 ? getAssignedMessageData(unusedVar)
                 : getDefinedMessageData(unusedVar),
+              ...getFixOrSuggest({
+                fixOrSuggest: options.enableAutofixRemoval?.imports
+                  ? 'fix'
+                  : 'suggest',
+                suggestion: {
+                  messageId: 'unusedVarSuggestion',
+                  fix: fixer,
+                },
+              }),
             });
 
             // If there are no regular declaration, report the first `/*globals*/` comment directive.

diff --git a/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars-eslint.test.ts b/packages/eslint-plugin/tests/rules/no-unused-vars/no-unused-vars-eslint.test.ts
@@ -385,7 +385,17 @@ function f() {
     },
     {
       code: "import x from 'y';",
-      errors: [definedError('x')],
+      errors: [
+        {
+          ...definedError('x'),
+          suggestions: [
+            {
+              messageId: 'unusedVarSuggestion',
+              output: '',
+            },
+          ],
+        },
+      ],
       languageOptions: {
         parserOptions: { ecmaVersion: 6, sourceType: 'module' },
       },