May 23, 2025 · May 23, 2025 · May 24, 2025 · Jun 3, 2025 · Jun 3, 2025 · Jun 4, 2025
diff --git a/packages/eslint-plugin/src/rules/no-unused-vars.ts b/packages/eslint-plugin/src/rules/no-unused-vars.ts
 import {
  collectVariables,
  createRule,
  getFixOrSuggest,
  getNameLocationInGlobalDirectiveComment,
  isDefinitionFile,
  isFunction,
 } 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'
      reportUsedIgnorePattern?: boolean;
      vars?: 'all' | 'local';
      varsIgnorePattern?: string;
      enableAutofixRemoval?: {
        imports: boolean;
      };
    },
 ];

  reportUsedIgnorePattern: boolean;
  vars: 'all' | 'local';
  varsIgnorePattern?: RegExp;
  enableAutofixRemoval?: {
    imports: boolean;
  };
 }

 type VariableType =
      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:
                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:
            'u',
          );
        }

        if (firstOption.enableAutofixRemoval) {
          options.enableAutofixRemoval = firstOption.enableAutofixRemoval;
        }
      }

      return options;
      // 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.
              },
            };

            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
    },
    {
      code: "import x from 'y';",
      errors: [definedError('x')],
      errors: [
        {
          ...definedError('x'),
          suggestions: [
            {
              messageId: 'unusedVarSuggestion',
              output: '',
            },
          ],
        },
      ],
      languageOptions: {
        parserOptions: { ecmaVersion: 6, sourceType: 'module' },
      },
Original file line number	Diff line number	Diff line change
Expand Up		@@ -15,6 +15,7 @@
		import {
		collectVariables,
		createRule,
		getFixOrSuggest,
		getNameLocationInGlobalDirectiveComment,
		isDefinitionFile,
		isFunction,
Expand All		@@ -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'
Expand All		@@ -38,6 +43,9 @@
		reportUsedIgnorePattern?: boolean;
		vars?: 'all' \| 'local';
		varsIgnorePattern?: string;
		enableAutofixRemoval?: {
		imports: boolean;
		};
		},
		];

Expand All		@@ -52,6 +60,9 @@
		reportUsedIgnorePattern: boolean;
		vars: 'all' \| 'local';
		varsIgnorePattern?: RegExp;
		enableAutofixRemoval?: {
		imports: boolean;
		};
		}

		type VariableType =
Expand All		@@ -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:
Expand DownExpand Up		@@ -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:
Expand DownExpand Up		@@ -208,6 +234,10 @@
		'u',
		);
		}

		if (firstOption.enableAutofixRemoval) {
		options.enableAutofixRemoval = firstOption.enableAutofixRemoval;
		}
		}

		return options;
Expand DownExpand Up		@@ -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.
Expand DownExpand Up		@@ -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;
Check warning on line 792 in packages/eslint-plugin/src/rules/no-unused-vars.ts View check run for this annotation Codecov/ codecov/patch packages/eslint-plugin/src/rules/no-unused-vars.ts#L792 `Added line #L792 was not covered by tests`

		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;
Check warning on line 835 in packages/eslint-plugin/src/rules/no-unused-vars.ts View check run for this annotation Codecov/ codecov/patch packages/eslint-plugin/src/rules/no-unused-vars.ts#L835 `Added line #L835 was not covered by tests`
		};

		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.
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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' },
		},
Expand Down