eslint-plugin-unicorn 61.0.2 → 62.0.0

package/index.js

@@ -1,7 +1,7 @@
 import createDeprecatedRules from './rules/utils/create-deprecated-rules.js';
 import flatConfigBase from './configs/flat-config-base.js';
 import * as rawRules from './rules/index.js';
-import {createRules} from './rules/utils/rule.js';
+import {createRules} from './rules/rule/index.js';
 import packageJson from './package.json' with {type: 'json'};
 
 const rules = createRules(rawRules);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eslint-plugin-unicorn",
-	"version": "61.0.2",
+	"version": "62.0.0",
 	"description": "More than 100 powerful ESLint rules",
 	"license": "MIT",
 	"repository": "sindresorhus/eslint-plugin-unicorn",
@@ -56,60 +56,62 @@
 		"xo"
 	],
 	"dependencies": {
-		"@babel/helper-validator-identifier": "^7.27.1",
-		"@eslint-community/eslint-utils": "^4.7.0",
-		"@eslint/plugin-kit": "^0.3.3",
+		"@babel/helper-validator-identifier": "^7.28.5",
+		"@eslint-community/eslint-utils": "^4.9.0",
+		"@eslint/plugin-kit": "^0.4.0",
 		"change-case": "^5.4.4",
-		"ci-info": "^4.3.0",
+		"ci-info": "^4.3.1",
 		"clean-regexp": "^1.0.0",
-		"core-js-compat": "^3.44.0",
+		"core-js-compat": "^3.46.0",
 		"esquery": "^1.6.0",
 		"find-up-simple": "^1.0.1",
-		"globals": "^16.3.0",
+		"globals": "^16.4.0",
 		"indent-string": "^5.0.0",
 		"is-builtin-module": "^5.0.0",
 		"jsesc": "^3.1.0",
 		"pluralize": "^8.0.0",
 		"regexp-tree": "^0.1.27",
-		"regjsparser": "^0.12.0",
-		"semver": "^7.7.2",
-		"strip-indent": "^4.0.0"
+		"regjsparser": "^0.13.0",
+		"semver": "^7.7.3",
+		"strip-indent": "^4.1.1"
 	},
 	"devDependencies": {
 		"@babel/code-frame": "^7.27.1",
-		"@babel/core": "^7.28.0",
-		"@babel/eslint-parser": "^7.28.0",
+		"@babel/core": "^7.28.5",
+		"@babel/eslint-parser": "^7.28.5",
 		"@eslint/eslintrc": "^3.3.1",
 		"@lubien/fixture-beta-package": "^1.0.0-beta.1",
-		"@typescript-eslint/parser": "^8.37.0",
+		"@typescript-eslint/parser": "^8.46.2",
+		"@typescript-eslint/types": "^8.46.2",
 		"ava": "^6.4.1",
 		"c8": "^10.1.3",
 		"enquirer": "^2.4.1",
-		"eslint": "^9.29.0",
+		"eslint": "^9.38.0",
 		"eslint-ava-rule-tester": "^5.0.1",
-		"eslint-config-xo": "^0.47.0",
-		"eslint-doc-generator": "^2.2.2",
-		"eslint-plugin-eslint-plugin": "^6.5.0",
-		"eslint-plugin-jsdoc": "^51.4.1",
-		"eslint-remote-tester": "^4.0.2",
+		"eslint-config-xo": "^0.49.0",
+		"eslint-doc-generator": "^2.3.0",
+		"eslint-plugin-eslint-plugin": "^7.1.0",
+		"eslint-plugin-jsdoc": "^61.1.6",
+		"eslint-plugin-unicorn": "^61.0.2",
+		"eslint-remote-tester": "^4.0.3",
 		"eslint-remote-tester-repositories": "^2.0.2",
 		"espree": "^10.4.0",
-		"listr2": "^9.0.1",
+		"listr2": "^9.0.5",
 		"lodash-es": "^4.17.21",
 		"markdownlint-cli": "^0.45.0",
-		"nano-spawn": "^1.0.2",
-		"node-style-text": "^1.0.0",
+		"nano-spawn": "^2.0.0",
+		"node-style-text": "^2.1.2",
 		"npm-package-json-lint": "^9.0.0",
 		"npm-run-all2": "^8.0.4",
 		"open-editor": "^5.1.0",
 		"outdent": "^0.8.0",
-		"pretty-ms": "^9.2.0",
-		"typescript": "^5.8.3",
+		"pretty-ms": "^9.3.0",
+		"typescript": "^5.9.3",
 		"vue-eslint-parser": "^10.2.0",
-		"yaml": "^2.8.0"
+		"yaml": "^2.8.1"
 	},
 	"peerDependencies": {
-		"eslint": ">=9.29.0"
+		"eslint": ">=9.38.0"
 	},
 	"ava": {
 		"files": [

package/readme.md

@@ -90,6 +90,7 @@ export default [
 | [no-empty-file](docs/rules/no-empty-file.md)                                                     | Disallow empty files.                                                                                                                                                                                             | ✅ ☑️ |    |    |
 | [no-for-loop](docs/rules/no-for-loop.md)                                                         | Do not use a `for` loop that can be replaced with a `for-of` loop.                                                                                                                                                | ✅    | 🔧 | 💡 |
 | [no-hex-escape](docs/rules/no-hex-escape.md)                                                     | Enforce the use of Unicode escapes instead of hexadecimal escapes.                                                                                                                                                | ✅ ☑️ | 🔧 |    |
+| [no-immediate-mutation](docs/rules/no-immediate-mutation.md)                                     | Disallow immediate mutation after variable assignment.                                                                                                                                                            | ✅    | 🔧 | 💡 |
 | [no-instanceof-builtins](docs/rules/no-instanceof-builtins.md)                                   | Disallow `instanceof` with built-in objects                                                                                                                                                                       | ✅ ☑️ | 🔧 | 💡 |
 | [no-invalid-fetch-options](docs/rules/no-invalid-fetch-options.md)                               | Disallow invalid options in `fetch()` and `new Request()`.                                                                                                                                                        | ✅ ☑️ |    |    |
 | [no-invalid-remove-event-listener](docs/rules/no-invalid-remove-event-listener.md)               | Prevent calling `EventTarget#removeEventListener()` with the result of an expression.                                                                                                                             | ✅ ☑️ |    |    |
@@ -118,6 +119,7 @@ export default [
 | [no-unreadable-array-destructuring](docs/rules/no-unreadable-array-destructuring.md)             | Disallow unreadable array destructuring.                                                                                                                                                                          | ✅ ☑️ | 🔧 |    |
 | [no-unreadable-iife](docs/rules/no-unreadable-iife.md)                                           | Disallow unreadable IIFEs.                                                                                                                                                                                        | ✅ ☑️ |    |    |
 | [no-unused-properties](docs/rules/no-unused-properties.md)                                       | Disallow unused object properties.                                                                                                                                                                                |      |    |    |
+| [no-useless-collection-argument](docs/rules/no-useless-collection-argument.md)                   | Disallow useless values or fallbacks in `Set`, `Map`, `WeakSet`, or `WeakMap`.                                                                                                                                    | ✅ ☑️ | 🔧 |    |
 | [no-useless-error-capture-stack-trace](docs/rules/no-useless-error-capture-stack-trace.md)       | Disallow unnecessary `Error.captureStackTrace(…)`.                                                                                                                                                                | ✅ ☑️ | 🔧 |    |
 | [no-useless-fallback-in-spread](docs/rules/no-useless-fallback-in-spread.md)                     | Disallow useless fallback when spreading in object literals.                                                                                                                                                      | ✅ ☑️ | 🔧 |    |
 | [no-useless-length-check](docs/rules/no-useless-length-check.md)                                 | Disallow useless array length check.                                                                                                                                                                              | ✅ ☑️ | 🔧 |    |
@@ -169,6 +171,7 @@ export default [
 | [prefer-query-selector](docs/rules/prefer-query-selector.md)                                     | Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()` and `.getElementsByName()`.                                              | ✅    | 🔧 |    |
 | [prefer-reflect-apply](docs/rules/prefer-reflect-apply.md)                                       | Prefer `Reflect.apply()` over `Function#apply()`.                                                                                                                                                                 | ✅ ☑️ | 🔧 |    |
 | [prefer-regexp-test](docs/rules/prefer-regexp-test.md)                                           | Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`.                                                                                                                                                 | ✅ ☑️ | 🔧 | 💡 |
+| [prefer-response-static-json](docs/rules/prefer-response-static-json.md)                         | Prefer `Response.json()` over `new Response(JSON.stringify())`.                                                                                                                                                   | ✅ ☑️ | 🔧 |    |
 | [prefer-set-has](docs/rules/prefer-set-has.md)                                                   | Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.                                                                                                                          | ✅ ☑️ | 🔧 | 💡 |
 | [prefer-set-size](docs/rules/prefer-set-size.md)                                                 | Prefer using `Set#size` instead of `Array#length`.                                                                                                                                                                | ✅ ☑️ | 🔧 |    |
 | [prefer-single-call](docs/rules/prefer-single-call.md)                                           | Enforce combining multiple `Array#push()`, `Element#classList.{add,remove}()`, and `importScripts()` into one call.                                                                                               | ✅ ☑️ | 🔧 | 💡 |

package/rules/ast/index.js

@@ -5,6 +5,7 @@ export {
 	isBigIntLiteral,
 	isNullLiteral,
 	isRegexLiteral,
+	isEmptyStringLiteral,
 } from './literal.js';
 
 export {
@@ -16,6 +17,7 @@ export {
 export {default as isArrowFunctionBody} from './is-arrow-function-body.js';
 export {default as isDirective} from './is-directive.js';
 export {default as isEmptyNode} from './is-empty-node.js';
+export {default as isEmptyArrayExpression} from './is-empty-array-expression.js';
 export {default as isExpressionStatement} from './is-expression-statement.js';
 export {default as isFunction} from './is-function.js';
 export {default as isMemberExpression} from './is-member-expression.js';

package/rules/ast/is-empty-array-expression.js

@@ -0,0 +1,5 @@
+const isEmptyArrayExpression = node =>
+	node.type === 'ArrayExpression'
+	&& node.elements.length === 0;
+
+export default isEmptyArrayExpression;

package/rules/ast/is-undefined.js

@@ -1,3 +1,3 @@
 export default function isUndefined(node) {
-	return node.type === 'Identifier' && node.name === 'undefined';
+	return node?.type === 'Identifier' && node.name === 'undefined';
 }

package/rules/ast/literal.js

@@ -21,3 +21,4 @@ export const isNullLiteral = node => isLiteral(node, null);
 
 export const isBigIntLiteral = node => node.type === 'Literal' && Boolean(node.bigint);
 
+export const isEmptyStringLiteral = node => isLiteral(node, '');

package/rules/catch-error-name.js

@@ -95,7 +95,7 @@ const create = context => {
 			};
 
 			if (fixedName) {
-				problem.fix = fixer => renameVariable(variable, fixedName, fixer);
+				problem.fix = fixer => renameVariable(variable, fixedName, context, fixer);
 			}
 
 			return problem;

package/rules/consistent-date-clone.js

@@ -32,7 +32,7 @@ const create = context => ({
 				end: sourceCode.getLoc(callExpression).end,
 			},
 			messageId: MESSAGE_ID_ERROR,
-			fix: fixer => removeMethodCall(fixer, callExpression, sourceCode),
+			fix: fixer => removeMethodCall(fixer, callExpression, context),
 		};
 	},
 });

package/rules/consistent-existence-index-check.js

@@ -101,7 +101,7 @@ const create = context => ({
 
 			yield {
 				node: binaryExpression,
-				loc: toLocation([start, end], sourceCode),
+				loc: toLocation([start, end], context),
 				messageId: MESSAGE_ID,
 				data: {
 					...replacement,

package/rules/consistent-function-scoping.js

@@ -108,6 +108,43 @@ const isIife = node =>
 	&& node.parent.type === 'CallExpression'
 	&& node.parent.callee === node;
 
+// Helper to walk up the chain to find the first non-arrow ancestor
+function getNonArrowAncestor(node) {
+	let ancestor = node;
+	while (ancestor && ancestor.type === 'ArrowFunctionExpression') {
+		ancestor = ancestor.parent;
+	}
+
+	return ancestor;
+}
+
+// Helper to skip over a chain of ArrowFunctionExpression nodes
+function skipArrowFunctionChain(node) {
+	let current = node;
+	while (current.type === 'ArrowFunctionExpression') {
+		current = current.parent;
+	}
+
+	return current;
+}
+
+function handleNestedArrowFunctions(parentNode, node) {
+	// Skip over arrow function expressions when they are parents and we came from a ReturnStatement
+	// This handles nested arrow functions: return next => action => { ... }
+	// But only when we're in a return statement context
+	if (parentNode.type === 'ArrowFunctionExpression' && node.type === 'ArrowFunctionExpression') {
+		const ancestor = getNonArrowAncestor(parentNode);
+		if (ancestor && ancestor.type === 'ReturnStatement') {
+			parentNode = skipArrowFunctionChain(parentNode);
+			if (parentNode.type === 'ReturnStatement') {
+				parentNode = parentNode.parent;
+			}
+		}
+	}
+
+	return parentNode;
+}
+
 function checkNode(node, scopeManager) {
 	const scope = scopeManager.acquire(node);
 
@@ -128,7 +165,15 @@ function checkNode(node, scopeManager) {
 		parentNode = parentNode.parent;
 	}
 
-	if (parentNode.type === 'BlockStatement') {
+	// Only skip ReturnStatement for arrow functions
+	// Regular function expressions have different semantics and shouldn't be moved
+	if (parentNode?.type === 'ReturnStatement' && node.type === 'ArrowFunctionExpression') {
+		parentNode = parentNode.parent;
+	}
+
+	parentNode = handleNestedArrowFunctions(parentNode, node);
+
+	if (parentNode?.type === 'BlockStatement') {
 		parentNode = parentNode.parent;
 	}
 

package/rules/escape-case.js

@@ -56,7 +56,7 @@ const create = context => {
 			node,
 			original: node.value.raw,
 			lowercase,
-			fix: (fixer, fixed) => replaceTemplateElement(fixer, node, fixed),
+			fix: (fixer, fixed) => replaceTemplateElement(node, fixed, context, fixer),
 		});
 	});
 };

package/rules/explicit-length-check.js

@@ -123,7 +123,7 @@ function create(context) {
 
 		const fix = function * (fixer) {
 			yield fixer.replaceText(node, fixed);
-			yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+			yield fixSpaceAroundKeyword(fixer, node, context);
 		};
 
 		const problem = {

package/rules/fix/add-parenthesizes-to-return-or-throw-expression.js

@@ -1,10 +1,22 @@
 import {isSemicolonToken} from '@eslint-community/eslint-utils';
 
-export default function * addParenthesizesToReturnOrThrowExpression(fixer, node, sourceCode) {
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.ReturnStatement | ESTree.ThrowStatement} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function * addParenthesizesToReturnOrThrowExpression(fixer, node, context) {
 	if (node.type !== 'ReturnStatement' && node.type !== 'ThrowStatement') {
 		return;
 	}
 
+	const {sourceCode} = context;
 	const returnOrThrowToken = sourceCode.getFirstToken(node);
 	yield fixer.insertTextAfter(returnOrThrowToken, ' (');
 	const lastToken = sourceCode.getLastToken(node);

package/rules/fix/append-argument.js

@@ -1,6 +1,18 @@
 import {isCommaToken} from '@eslint-community/eslint-utils';
 
-export default function appendArgument(fixer, node, text, sourceCode) {
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.CallExpression} node
+@param {string} text
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function appendArgument(fixer, node, text, context) {
 	// This function should also work for `NewExpression`
 	// But parentheses of `NewExpression` could be omitted, add this check to prevent accident use on it
 	/* c8 ignore next 3 */
@@ -8,6 +20,7 @@ export default function appendArgument(fixer, node, text, sourceCode) {
 		throw new Error(`Unexpected node "${node.type}".`);
 	}
 
+	const {sourceCode} = context;
 	const [penultimateToken, lastToken] = sourceCode.getLastTokens(node, 2);
 	if (node.arguments.length > 0) {
 		text = isCommaToken(penultimateToken) ? ` ${text},` : `, ${text}`;

package/rules/fix/fix-space-around-keywords.js

@@ -1,5 +1,10 @@
 import {getParenthesizedRange} from '../utils/parentheses.js';
 
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
 const isProblematicToken = ({type, value}) => (
 	(type === 'Keyword' && /^[a-z]*$/.test(value))
 	// ForOfStatement
@@ -8,8 +13,14 @@ const isProblematicToken = ({type, value}) => (
 	|| (type === 'Identifier' && value === 'await')
 );
 
-export default function * fixSpaceAroundKeyword(fixer, node, sourceCode) {
-	const range = getParenthesizedRange(node, sourceCode);
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.Node} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+*/
+export default function * fixSpaceAroundKeyword(fixer, node, context) {
+	const {sourceCode} = context;
+	const range = getParenthesizedRange(node, context);
 	const tokenBefore = sourceCode.getTokenBefore({range}, {includeComments: true});
 
 	if (

package/rules/fix/index.js

@@ -10,13 +10,14 @@ export {
 	removeMemberExpressionProperty,
 } from './replace-member-expression-property.js';
 export {default as removeMethodCall} from './remove-method-call.js';
-export {default as replaceTemplateElement} from './replace-template-element.js';
-export {default as replaceReferenceIdentifier} from './replace-reference-identifier.js';
-export {default as renameVariable} from './rename-variable.js';
-export {default as replaceNodeOrTokenAndSpacesBefore} from './replace-node-or-token-and-spaces-before.js';
+export {default as removeExpressionStatement} from './remove-expression-statement.js';
 export {default as removeSpacesAfter} from './remove-spaces-after.js';
 export {default as removeSpecifier} from './remove-specifier.js';
 export {default as removeObjectProperty} from './remove-object-property.js';
+export {default as renameVariable} from './rename-variable.js';
+export {default as replaceTemplateElement} from './replace-template-element.js';
+export {default as replaceReferenceIdentifier} from './replace-reference-identifier.js';
+export {default as replaceNodeOrTokenAndSpacesBefore} from './replace-node-or-token-and-spaces-before.js';
 export {default as fixSpaceAroundKeyword} from './fix-space-around-keywords.js';
 export {default as replaceStringRaw} from './replace-string-raw.js';
 export {default as addParenthesizesToReturnOrThrowExpression} from './add-parenthesizes-to-return-or-throw-expression.js';

package/rules/fix/remove-argument.js

@@ -1,12 +1,24 @@
 import {isCommaToken} from '@eslint-community/eslint-utils';
 import {getParentheses} from '../utils/parentheses.js';
 
-export default function removeArgument(fixer, node, sourceCode) {
-	const callExpression = node.parent;
-	const index = callExpression.arguments.indexOf(node);
-	const parentheses = getParentheses(node, sourceCode);
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.NewExpression | ESTree.CallExpression} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function removeArgument(fixer, node, context) {
+	const callOrNewExpression = node.parent;
+	const index = callOrNewExpression.arguments.indexOf(node);
+	const parentheses = getParentheses(node, context);
 	const firstToken = parentheses[0] || node;
 	const lastToken = parentheses.at(-1) || node;
+	const {sourceCode} = context;
 
 	let [start] = sourceCode.getRange(firstToken);
 	let [, end] = sourceCode.getRange(lastToken);
@@ -17,14 +29,12 @@ export default function removeArgument(fixer, node, sourceCode) {
 	}
 
 	// If the removed argument is the only argument, the trailing comma must be removed too
-	/* c8 ignore start */
-	if (callExpression.arguments.length === 1) {
-		const tokenAfter = sourceCode.getTokenBefore(lastToken);
+	if (callOrNewExpression.arguments.length === 1) {
+		const tokenAfter = sourceCode.getTokenAfter(lastToken);
 		if (isCommaToken(tokenAfter)) {
 			[, end] = sourceCode.getRange(tokenAfter);
 		}
 	}
-	/* c8 ignore end */
 
 	return fixer.removeRange([start, end]);
 }

package/rules/fix/remove-expression-statement.js

@@ -0,0 +1,34 @@
+import {isSemicolonToken} from '@eslint-community/eslint-utils';
+const isWhitespaceOnly = text => /^\s*$/.test(text);
+
+function removeExpressionStatement(expressionStatement, context, fixer, preserveSemiColon = false) {
+	const {sourceCode} = context;
+	const {lines} = sourceCode;
+	let endToken = expressionStatement;
+
+	if (preserveSemiColon) {
+		const [penultimateToken, lastToken] = sourceCode.getLastTokens(expressionStatement, 2);
+
+		if (isSemicolonToken(lastToken)) {
+			endToken = penultimateToken;
+		}
+	}
+
+	const startLocation = sourceCode.getLoc(expressionStatement).start;
+	const endLocation = sourceCode.getLoc(endToken).end;
+
+	const textBefore = lines[startLocation.line - 1].slice(0, startLocation.column);
+	const textAfter = lines[endLocation.line - 1].slice(endLocation.column);
+
+	let [start] = sourceCode.getRange(expressionStatement);
+	let [, end] = sourceCode.getRange(endToken);
+
+	if (isWhitespaceOnly(textBefore) && isWhitespaceOnly(textAfter)) {
+		start = Math.max(0, start - textBefore.length - 1);
+		end += textAfter.length;
+	}
+
+	return fixer.removeRange([start, end]);
+}
+
+export default removeExpressionStatement;

package/rules/fix/remove-method-call.js

@@ -1,17 +1,28 @@
 import {getParenthesizedRange} from '../utils/parentheses.js';
 import {removeMemberExpressionProperty} from './replace-member-expression-property.js';
 
-export default function * removeMethodCall(fixer, callExpression, sourceCode) {
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.CallExpression} callExpression
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function * removeMethodCall(fixer, callExpression, context) {
 	const memberExpression = callExpression.callee;
 
 	// `(( (( foo )).bar ))()`
 	//              ^^^^
-	yield removeMemberExpressionProperty(fixer, memberExpression, sourceCode);
+	yield removeMemberExpressionProperty(fixer, memberExpression, context);
 
 	// `(( (( foo )).bar ))()`
 	//                     ^^
-	const [, start] = getParenthesizedRange(memberExpression, sourceCode);
-	const [, end] = sourceCode.getRange(callExpression);
+	const [, start] = getParenthesizedRange(memberExpression, context);
+	const [, end] = context.sourceCode.getRange(callExpression);
 
 	yield fixer.removeRange([start, end]);
 }

package/rules/fix/remove-parentheses.js

@@ -1,7 +1,18 @@
 import {getParentheses} from '../utils/parentheses.js';
 
-export default function * removeParentheses(node, fixer, sourceCode) {
-	const parentheses = getParentheses(node, sourceCode);
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESTree.Node} node
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function * removeParentheses(node, fixer, context) {
+	const parentheses = getParentheses(node, context);
 	for (const token of parentheses) {
 		yield fixer.remove(token);
 	}

package/rules/fix/remove-spaces-after.js

@@ -1,10 +1,22 @@
-export default function removeSpacesAfter(indexOrNodeOrToken, sourceCode, fixer) {
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESTree.Node | ESTree.Token | number} indexOrNodeOrToken
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@param {ESLint.Rule.RuleFixer} fixer
+@returns {ESLint.Rule.ReportFixer}
+*/
+
+export default function removeSpacesAfter(indexOrNodeOrToken, context, fixer) {
 	let index = indexOrNodeOrToken;
 	if (typeof indexOrNodeOrToken === 'object') {
-		index = sourceCode.getRange(indexOrNodeOrToken)[1];
+		index = context.sourceCode.getRange(indexOrNodeOrToken)[1];
 	}
 
-	const textAfter = sourceCode.text.slice(index);
+	const textAfter = context.sourceCode.text.slice(index);
 	const [leadingSpaces] = textAfter.match(/^\s*/);
 	return fixer.removeRange([index, index + leadingSpaces.length]);
 }

package/rules/fix/remove-specifier.js

@@ -1,6 +1,18 @@
 import {isCommaToken, isOpeningBraceToken} from '@eslint-community/eslint-utils';
 
-export default function * removeSpecifier(specifier, fixer, sourceCode, keepDeclaration = false) {
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESTree.ImportSpecifier | ESTree.ExportSpecifier | ESTree.ImportDefaultSpecifier | ESTree.ImportNamespaceSpecifier} specifier
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@param {boolean} [keepDeclaration = false]
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function * removeSpecifier(specifier, fixer, context, keepDeclaration = false) {
 	const declaration = specifier.parent;
 	const {specifiers} = declaration;
 
@@ -9,6 +21,7 @@ export default function * removeSpecifier(specifier, fixer, sourceCode, keepDecl
 		return;
 	}
 
+	const {sourceCode} = context;
 	switch (specifier.type) {
 		case 'ImportSpecifier': {
 			const isTheOnlyNamedImport = specifiers.every(node => specifier === node || specifier.type !== node.type);

package/rules/fix/rename-variable.js

@@ -1,7 +1,8 @@
 import getVariableIdentifiers from '../utils/get-variable-identifiers.js';
 import replaceReferenceIdentifier from './replace-reference-identifier.js';
 
-const renameVariable = (variable, name, fixer) => getVariableIdentifiers(variable)
-	.map(identifier => replaceReferenceIdentifier(identifier, name, fixer));
+const renameVariable = (variable, name, context, fixer) =>
+	getVariableIdentifiers(variable)
+		.map(identifier => replaceReferenceIdentifier(identifier, name, context, fixer));
 
 export default renameVariable;

package/rules/fix/replace-argument.js

@@ -1,5 +1,17 @@
 import {getParenthesizedRange} from '../utils/parentheses.js';
 
-export default function replaceArgument(fixer, node, text, sourceCode) {
-	return fixer.replaceTextRange(getParenthesizedRange(node, sourceCode), text);
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESLint.Rule.RuleFixer} fixer
+@param {ESTree.CallExpression | ESTree.NewExpression} node
+@param {string} text
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export default function replaceArgument(fixer, node, text, context) {
+	return fixer.replaceTextRange(getParenthesizedRange(node, context), text);
 }

package/rules/fix/replace-member-expression-property.js

@@ -1,9 +1,25 @@
 import {getParenthesizedRange} from '../utils/parentheses.js';
 
-export function replaceMemberExpressionProperty(fixer, memberExpression, sourceCode, text) {
-	const [, start] = getParenthesizedRange(memberExpression.object, sourceCode);
-	const [, end] = sourceCode.getRange(memberExpression);
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@param {ESTree.MemberExpression} memberExpression - The `MemberExpression` to fix.
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@param {string} text
+@returns {ESLint.Rule.ReportFixer}
+*/
+export function replaceMemberExpressionProperty(fixer, memberExpression, context, text) {
+	const [, start] = getParenthesizedRange(memberExpression.object, context);
+	const [, end] = context.sourceCode.getRange(memberExpression);
 	return fixer.replaceTextRange([start, end], text);
 }
 
-export const removeMemberExpressionProperty = (fixer, memberExpression, sourceCode) => replaceMemberExpressionProperty(fixer, memberExpression, sourceCode, '');
+/**
+@param {ESTree.MemberExpression} memberExpression - The `MemberExpression` to fix.
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export const removeMemberExpressionProperty = (fixer, memberExpression, context) => replaceMemberExpressionProperty(fixer, memberExpression, context, '');