eslint-plugin-unicorn 69.0.0 → 71.0.0

package/rules/no-mismatched-map-key.js

@@ -1,7 +1,7 @@
 import {findVariable, getStaticValue} from '@eslint-community/eslint-utils';
 import {isMethodCall} from './ast/index.js';
 import {isReference, isSame, unwrapExpression} from './utils/comparison.js';
-import {isKnownNonMap} from './utils/index.js';
+import {isComparableStaticValue, isKnownNonMap} from './utils/index.js';
 
 /**
 @import {TSESTree as ESTree} from '@typescript-eslint/types';
@@ -21,13 +21,6 @@ const skippedNodeTypes = new Set([
 	'FunctionExpression',
 ]);
 
-const isComparableStaticValue = value =>
-	value === null
-	|| (
-		typeof value !== 'object'
-		&& typeof value !== 'function'
-	);
-
 const isSameValueZero = (left, right) =>
 	left === right
 	|| (
@@ -132,7 +125,7 @@ function patternContainsSameBinding(node, mapHasRoot, context) {
 
 function hasCallExpression(node, context) {
 	const {visitorKeys} = context.sourceCode;
-	let result = false;
+	let isResult = false;
 
 	function visit(node) {
 		if (!node) {
@@ -142,14 +135,14 @@ function hasCallExpression(node, context) {
 		node = unwrapExpression(node);
 
 		if (
-			result
+			isResult
 			|| skippedNodeTypes.has(node.type)
 		) {
 			return;
 		}
 
 		if (node.type === 'CallExpression') {
-			result = true;
+			isResult = true;
 			return;
 		}
 
@@ -170,7 +163,7 @@ function hasCallExpression(node, context) {
 
 	visit(node);
 
-	return result;
+	return isResult;
 }
 
 function areDifferentKeys(left, right, context) {
@@ -353,11 +346,11 @@ function isNestedMapHasGuard(node, mapHasCall, context) {
 
 function hasSameMapHasCall(node, mapHasCall, context) {
 	const {visitorKeys} = context.sourceCode;
-	let result = false;
+	let isResult = false;
 
 	function visit(node) {
 		if (
-			result
+			isResult
 			|| !node
 			|| skippedNodeTypes.has(node.type)
 		) {
@@ -370,7 +363,7 @@ function hasSameMapHasCall(node, mapHasCall, context) {
 			nestedMapHasCall
 			&& isSameMapReceiver(unwrapExpression(mapHasCall).callee.object, unwrapExpression(nestedMapHasCall).callee.object, context)
 		) {
-			result = true;
+			isResult = true;
 			return;
 		}
 
@@ -391,16 +384,16 @@ function hasSameMapHasCall(node, mapHasCall, context) {
 
 	visit(node);
 
-	return result;
+	return isResult;
 }
 
 function hasMapReceiverWrite(node, mapHasCall, context) {
 	const {visitorKeys} = context.sourceCode;
-	let result = false;
+	let isResult = false;
 
 	function visit(node) {
 		if (
-			result
+			isResult
 			|| !node
 			|| skippedNodeTypes.has(node.type)
 			|| isNestedMapHasGuard(node, mapHasCall, context)
@@ -409,7 +402,7 @@ function hasMapReceiverWrite(node, mapHasCall, context) {
 		}
 
 		if (isMapReceiverWrite(node, mapHasCall, context)) {
-			result = true;
+			isResult = true;
 			return;
 		}
 
@@ -430,7 +423,7 @@ function hasMapReceiverWrite(node, mapHasCall, context) {
 
 	visit(node);
 
-	return result;
+	return isResult;
 }
 
 function getMapAccessProblems(node, mapHasCall, context, reportedAccessKeys) {

package/rules/no-named-default.js

@@ -97,12 +97,9 @@ const create = context => {
 	});
 
 	context.on('ExportSpecifier', specifier => {
-		if (!(
-			isValueExport(specifier)
+		if (!(isValueExport(specifier)
 			&& specifier.exported.name === 'default'
-			&& isValueExport(specifier.parent)
-			&& !specifier.parent.source
-		)) {
+			&& isValueExport(specifier.parent)) || specifier.parent.source) {
 			return;
 		}
 

package/rules/no-negated-array-predicate.js

@@ -8,7 +8,7 @@ import {
 	shouldAddParenthesesToUnaryExpressionArgument,
 } from './utils/index.js';
 import {
-	addParenthesizesToReturnOrThrowExpression,
+	addParenthesesToReturnOrThrowExpression,
 	fixSpaceAroundKeyword,
 } from './fix/index.js';
 import {isFunction, isMethodCall} from './ast/index.js';
@@ -24,13 +24,6 @@ const replacementMethod = new Map([
 ]);
 const methods = replacementMethod.keys().toArray();
 
-const predicateBodyTypesRequiringParentheses = new Set([
-	'TSAsExpression',
-	'TSNonNullExpression',
-	'TSSatisfiesExpression',
-	'TSTypeAssertion',
-]);
-
 const needsParenthesesInConciseArrowBody = (node, text) =>
 	node.parent.type === 'ArrowFunctionExpression'
 	&& node.parent.body === node
@@ -75,7 +68,7 @@ function getReplacementPredicateText(node, context) {
 	}
 
 	const text = context.sourceCode.getText(node);
-	const needsParentheses = predicateBodyTypesRequiringParentheses.has(node.type) || shouldAddParenthesesToUnaryExpressionArgument(node, '!');
+	const needsParentheses = shouldAddParenthesesToUnaryExpressionArgument(node, '!');
 
 	return {
 		node,
@@ -158,7 +151,7 @@ const create = context => {
 				replacement,
 			},
 			* fix(fixer) {
-				const needsReturnOrThrowParentheses = (
+				const isNeedsReturnOrThrowParentheses = (
 					(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 					&& parent.argument === unaryExpression
 					&& !isOnSameLine(bangToken, tokenAfterBang, context)
@@ -171,13 +164,13 @@ const create = context => {
 
 				if (
 					tokenStore === sourceCode
-					&& !needsReturnOrThrowParentheses
+					&& !isNeedsReturnOrThrowParentheses
 				) {
 					yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 				}
 
-				if (needsReturnOrThrowParentheses) {
-					yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+				if (isNeedsReturnOrThrowParentheses) {
+					yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 					return;
 				}
 

package/rules/no-negated-comparison.js

@@ -1,13 +1,21 @@
 import {
 	removeParentheses,
 	fixSpaceAroundKeyword,
-	addParenthesizesToReturnOrThrowExpression,
+	addParenthesesToReturnOrThrowExpression,
 } from './fix/index.js';
 import {
 	isParenthesized,
 	isOnSameLine,
 	needsSemicolon,
 } from './utils/index.js';
+import {
+	getBinaryExpressionWithReplacedOperatorText,
+	getPunctuatorBinaryExpressionOperatorToken,
+	hasLowerLogicalOperatorPrecedence,
+	negatedComparisonOperators,
+	negatedEqualityOperators,
+	negatedLogicalOperators,
+} from './utils/comparison.js';
 
 const MESSAGE_ID_ERROR = 'no-negated-comparison/error';
 const MESSAGE_ID_LOGICAL_ERROR = 'no-negated-comparison/logical-error';
@@ -20,29 +28,6 @@ const messages = {
 	[MESSAGE_ID_LOGICAL_SUGGESTION]: 'Switch to opposite comparisons.',
 };
 
-const operatorReplacements = new Map([
-	['===', '!=='],
-	['!==', '==='],
-	['==', '!='],
-	['!=', '=='],
-	['>', '<='],
-	['>=', '<'],
-	['<', '>='],
-	['<=', '>'],
-]);
-
-const safelyFixableOperators = new Set([
-	'===',
-	'!==',
-	'==',
-	'!=',
-]);
-
-const logicalOperatorReplacements = new Map([
-	['&&', '||'],
-	['||', '&&'],
-]);
-
 const defaultOptions = {
 	checkLogicalExpressions: false,
 };
@@ -72,20 +57,20 @@ const isNegation = node =>
 
 const isComparison = node =>
 	node.type === 'BinaryExpression'
-	&& operatorReplacements.has(node.operator);
+	&& negatedComparisonOperators.has(node.operator);
 
 const isLogicalExpressionWithOnlyComparisons = node =>
 	isComparison(node)
 	|| (
 		node.type === 'LogicalExpression'
-		&& logicalOperatorReplacements.has(node.operator)
+		&& negatedLogicalOperators.has(node.operator)
 		&& isLogicalExpressionWithOnlyComparisons(node.left)
 		&& isLogicalExpressionWithOnlyComparisons(node.right)
 	);
 
 const isSafelyFixableLogicalExpression = node =>
 	isComparison(node)
-		? safelyFixableOperators.has(node.operator)
+		? negatedEqualityOperators.has(node.operator)
 		: isSafelyFixableLogicalExpression(node.left) && isSafelyFixableLogicalExpression(node.right);
 
 const parentNeedsGroupedComparison = parent => [
@@ -111,19 +96,16 @@ function * fix({
 	const bangToken = sourceCode.getFirstToken(unaryExpression);
 	const tokenAfterBang = sourceCode.getTokenAfter(bangToken);
 	const tokenAfterBangIncludingComments = sourceCode.getTokenAfter(bangToken, {includeComments: true});
-	const operatorToken = sourceCode.getTokenAfter(
-		comparison.left,
-		token => token.type === 'Punctuator' && token.value === comparison.operator,
-	);
+	const operatorToken = getPunctuatorBinaryExpressionOperatorToken(comparison, context);
 	const {parent} = unaryExpression;
-	const needsReturnOrThrowParentheses = (
+	const isNeedsReturnOrThrowParentheses = (
 		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 		&& parent.argument === unaryExpression
 		&& !isOnSameLine(bangToken, tokenAfterBang, context)
 		&& !isParenthesized(unaryExpression, context)
 	);
 
-	if (!needsReturnOrThrowParentheses) {
+	if (!isNeedsReturnOrThrowParentheses) {
 		yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 	}
 
@@ -135,17 +117,14 @@ function * fix({
 		yield fixer.insertTextAfter(tokenAfterBangIncludingComments, ' ');
 	}
 
-	if (!(
-		parentNeedsGroupedComparison(parent)
-		&& !isParenthesized(unaryExpression, context)
-	)) {
+	if (!parentNeedsGroupedComparison(parent) || isParenthesized(unaryExpression, context)) {
 		yield removeParentheses(comparison, fixer, context);
 	}
 
 	yield fixer.replaceText(operatorToken, replacementOperator);
 
-	if (needsReturnOrThrowParentheses) {
-		yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+	if (isNeedsReturnOrThrowParentheses) {
+		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}
 
@@ -156,37 +135,18 @@ function * fix({
 	}
 }
 
-const logicalOperatorPrecedence = {
-	'||': 1,
-	'&&': 2,
-};
-
-const getOperatorToken = (comparison, sourceCode) => sourceCode.getTokenAfter(
-	comparison.left,
-	token => token.type === 'Punctuator' && token.value === comparison.operator,
+const getFixedComparisonText = (comparison, context) => getBinaryExpressionWithReplacedOperatorText(
+	comparison,
+	context,
+	negatedComparisonOperators.get(comparison.operator),
 );
 
-const getFixedComparisonText = (comparison, sourceCode) => {
-	const operatorToken = getOperatorToken(comparison, sourceCode);
-	const [comparisonStart] = sourceCode.getRange(comparison);
-	const [operatorStart, operatorEnd] = sourceCode.getRange(operatorToken);
-	const comparisonText = sourceCode.getText(comparison);
-
-	return [
-		comparisonText.slice(0, operatorStart - comparisonStart),
-		operatorReplacements.get(comparison.operator),
-		comparisonText.slice(operatorEnd - comparisonStart),
-	].join('');
-};
-
 const getFixedLogicalExpressionText = (node, context, parentOperator) => {
-	const {sourceCode} = context;
-
 	if (isComparison(node)) {
-		return getFixedComparisonText(node, sourceCode);
+		return getFixedComparisonText(node, context);
 	}
 
-	const operator = logicalOperatorReplacements.get(node.operator);
+	const operator = negatedLogicalOperators.get(node.operator);
 	const text = [
 		getFixedLogicalExpressionText(node.left, context, operator),
 		operator,
@@ -197,7 +157,7 @@ const getFixedLogicalExpressionText = (node, context, parentOperator) => {
 			operator !== parentOperator
 			&& isParenthesized(node, context)
 		)
-		|| logicalOperatorPrecedence[operator] < logicalOperatorPrecedence[parentOperator]
+		|| hasLowerLogicalOperatorPrecedence(operator, parentOperator)
 	);
 
 	return needsParentheses
@@ -215,22 +175,22 @@ function * fixLogical({
 	const bangToken = sourceCode.getFirstToken(unaryExpression);
 	const tokenAfterBang = sourceCode.getTokenAfter(bangToken);
 	const {parent} = unaryExpression;
-	const needsReturnOrThrowParentheses = (
+	const isNeedsReturnOrThrowParentheses = (
 		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
 		&& parent.argument === unaryExpression
 		&& !isOnSameLine(bangToken, tokenAfterBang, context)
 		&& !isParenthesized(unaryExpression, context)
 	);
 
-	if (!needsReturnOrThrowParentheses) {
+	if (!isNeedsReturnOrThrowParentheses) {
 		yield fixSpaceAroundKeyword(fixer, unaryExpression, context);
 	}
 
 	yield fixer.remove(bangToken);
 	yield fixer.replaceText(logicalExpression, getFixedLogicalExpressionText(logicalExpression, context));
 
-	if (needsReturnOrThrowParentheses) {
-		yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+	if (isNeedsReturnOrThrowParentheses) {
+		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}
 
@@ -253,7 +213,7 @@ const create = context => {
 
 		if (isComparison(argument)) {
 			const comparison = argument;
-			const replacementOperator = operatorReplacements.get(comparison.operator);
+			const replacementOperator = negatedComparisonOperators.get(comparison.operator);
 			const problem = {
 				node: unaryExpression,
 				messageId: MESSAGE_ID_ERROR,
@@ -267,7 +227,7 @@ const create = context => {
 				replacementOperator,
 			});
 
-			if (safelyFixableOperators.has(comparison.operator)) {
+			if (negatedEqualityOperators.has(comparison.operator)) {
 				problem.fix = fixFunction;
 			} else {
 				problem.suggest = [

package/rules/no-negated-condition.js

@@ -5,7 +5,7 @@ https://github.com/eslint/eslint/blob/5c39425fc55ecc0b97bbd07ac22654c0eb4f789c/l
 import {
 	removeParentheses,
 	fixSpaceAroundKeyword,
-	addParenthesizesToReturnOrThrowExpression,
+	addParenthesesToReturnOrThrowExpression,
 } from './fix/index.js';
 import {
 	getParenthesizedRange,
@@ -118,7 +118,7 @@ const create = context => {
 					&& !isParenthesized(node, context)
 					&& !isParenthesized(test, context)
 				) {
-					yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+					yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 					return;
 				}
 

package/rules/no-negation-in-equality-check.js

@@ -1,4 +1,4 @@
-import {fixSpaceAroundKeyword, addParenthesizesToReturnOrThrowExpression} from './fix/index.js';
+import {fixSpaceAroundKeyword, addParenthesesToReturnOrThrowExpression} from './fix/index.js';
 import {needsSemicolon, isParenthesized, isOnSameLine} from './utils/index.js';
 
 const MESSAGE_ID_ERROR = 'no-negation-in-equality-check/error';
@@ -23,11 +23,8 @@ const create = context => {
 	context.on('BinaryExpression', binaryExpression => {
 		const {operator, left} = binaryExpression;
 
-		if (!(
-			isEqualityCheck(binaryExpression)
-			&& isNegatedExpression(left)
-			&& !isNegatedExpression(left.argument)
-		)) {
+		if (!(isEqualityCheck(binaryExpression)
+			&& isNegatedExpression(left)) || isNegatedExpression(left.argument)) {
 			return;
 		}
 
@@ -58,7 +55,7 @@ const create = context => {
 						) {
 							const returnToken = sourceCode.getFirstToken(parent);
 							if (!isOnSameLine(returnToken, tokenAfterBang, context)) {
-								yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+								yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 							}
 						}
 

package/rules/no-non-function-verb-prefix.js

@@ -1,3 +1,4 @@
+import {isRegExp} from 'node:util/types';
 import {
 	isNullishType,
 	isTypeScriptFile,
@@ -31,8 +32,12 @@ const messages = {
 
 const isUppercaseAscii = character => character >= 'A' && character <= 'Z';
 
-const prepareOptions = ({verbs}) => ({
+const prepareOptions = ({
+	verbs,
+	ignore = [],
+}) => ({
 	verbs: verbs.toSorted((first, second) => second.length - first.length),
+	ignore: ignore.map(pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u')),
 });
 
 function getVerbPrefix(name, verbs) {
@@ -129,6 +134,15 @@ const getIntersectionTypeCallability = (type, checker, program, visitedTypes) =>
 const isInDeclaredModule = (node, sourceCode) =>
 	sourceCode.getAncestors(node).some(ancestor => ancestor.type === 'TSModuleDeclaration' && ancestor.declare);
 
+function isIgnoredName(name, ignore) {
+	return ignore.some(regexp => {
+		regexp.lastIndex = 0;
+		const isIgnored = regexp.test(name);
+		regexp.lastIndex = 0;
+		return isIgnored;
+	});
+}
+
 function getTypeCallability(type, checker, program, visitedTypes = new Set()) {
 	if (isIgnoredType(type)) {
 		return unknown;
@@ -184,6 +198,10 @@ function getProblem(identifier, context, options, typeNode = identifier) {
 		return;
 	}
 
+	if (isIgnoredName(identifier.name, options.ignore)) {
+		return;
+	}
+
 	const {parserServices} = context.sourceCode;
 	let type;
 	try {
@@ -298,6 +316,11 @@ const schema = [
 				uniqueItems: true,
 				description: 'Function-style verb prefixes to check.',
 			},
+			ignore: {
+				type: 'array',
+				uniqueItems: true,
+				description: 'Patterns to ignore.',
+			},
 		},
 	},
 ];
@@ -313,7 +336,7 @@ const config = {
 			requiresTypeChecking: true,
 		},
 		schema,
-		defaultOptions: [{verbs: defaultVerbs}],
+		defaultOptions: [{verbs: defaultVerbs, ignore: []}],
 		messages,
 		languages: [
 			'js/js',

package/rules/no-process-exit.js

@@ -11,9 +11,9 @@ const isWorkerThreads = node =>
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const startsWithHashBang = context.sourceCode.lines[0].indexOf('#!') === 0;
+	const isStartsWithHashBang = context.sourceCode.lines[0].indexOf('#!') === 0;
 
-	if (startsWithHashBang) {
+	if (isStartsWithHashBang) {
 		return;
 	}
 
@@ -22,7 +22,7 @@ const create = context => {
 	let processEventHandlerDepth = 0;
 
 	// Only report if it's outside a worker thread context. See #328.
-	let requiredWorkerThreadsModule = false;
+	let isRequiredWorkerThreadsModule = false;
 	const problemNodes = [];
 
 	const isProcessEventHandler = node => isMethodCall(node, {
@@ -39,7 +39,7 @@ const create = context => {
 			isStaticRequire(callExpression)
 			&& isWorkerThreads(callExpression.arguments[0])
 		) {
-			requiredWorkerThreadsModule = true;
+			isRequiredWorkerThreadsModule = true;
 		}
 	});
 
@@ -49,7 +49,7 @@ const create = context => {
 			importDeclaration.source.type === 'Literal'
 			&& isWorkerThreads(importDeclaration.source)
 		) {
-			requiredWorkerThreadsModule = true;
+			isRequiredWorkerThreadsModule = true;
 		}
 	});
 
@@ -81,7 +81,7 @@ const create = context => {
 	});
 
 	context.onExit('Program', function * () {
-		if (requiredWorkerThreadsModule) {
+		if (isRequiredWorkerThreadsModule) {
 			return;
 		}
 

package/rules/no-return-array-push.js

@@ -1,5 +1,5 @@
 import {isMethodCall} from './ast/index.js';
-import {isKnownNonArray, needsSemicolon} from './utils/index.js';
+import {isArray, isKnownNonArray, needsSemicolon} from './utils/index.js';
 
 const MESSAGE_ID_ERROR = 'no-return-array-push/error';
 const MESSAGE_ID_SUGGESTION = 'no-return-array-push/suggestion';
@@ -10,7 +10,10 @@ const messages = {
 
 const ignoredCallees = [
 	'stream.push',
+	'router.push',
 	'this.push',
+	'this.router.push',
+	'this.$router.push',
 	'this.stream.push',
 	'process.stdin.push',
 	'process.stdout.push',
@@ -53,6 +56,10 @@ function isStaticMemberPath(node, path) {
 
 const isIgnoredCallee = callee => ignoredCallees.some(ignoredCallee => isStaticMemberPath(callee, ignoredCallee));
 
+const isIgnoredPushCallee = (callExpression, context) =>
+	isIgnoredCallee(callExpression.callee)
+	&& !isArray(callExpression.callee.object, context);
+
 function getCallExpressionResultNode(callExpression) {
 	let node = callExpression;
 
@@ -133,7 +140,7 @@ const create = context => {
 		const {name: method} = property;
 
 		if (
-			(method === 'push' && isIgnoredCallee(callExpression.callee))
+			(method === 'push' && isIgnoredPushCallee(callExpression, context))
 			|| isReturnValueDiscarded(callExpression)
 			|| isResultMemberAccessed(callExpression)
 			|| isKnownNonArray(callExpression.callee.object, context)

package/rules/no-static-only-class.js

@@ -38,16 +38,10 @@ function isStaticMember(node) {
 	}
 
 	// TypeScript class
-	if (
-		isDeclare
+	return !(isDeclare
 		|| isReadonly
 		|| accessibility !== undefined
-		|| (Array.isArray(decorators) && decorators.length > 0)
-	) {
-		return false;
-	}
-
-	return true;
+		|| (Array.isArray(decorators) && decorators.length > 0));
 }
 
 function * switchClassMemberToObjectProperty(node, context, fixer) {

package/rules/no-thenable.js

@@ -79,16 +79,13 @@ const cases = [
 	{
 		selector: 'CallExpression',
 		* getNodes(node, context) {
-			if (!(
-				isMethodCall(node, {
-					objects: ['Object', 'Reflect'],
-					method: 'defineProperty',
-					minimumArguments: 3,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				&& node.arguments[0].type !== 'SpreadElement'
-			)) {
+			if (!isMethodCall(node, {
+				objects: ['Object', 'Reflect'],
+				method: 'defineProperty',
+				minimumArguments: 3,
+				optionalCall: false,
+				optionalMember: false,
+			}) || node.arguments[0].type === 'SpreadElement') {
 				return;
 			}
 
@@ -117,11 +114,8 @@ const cases = [
 			}
 
 			for (const pairs of node.arguments[0].elements) {
-				if (!(
-					pairs?.type === 'ArrayExpression'
-					&& pairs.elements[0]
-					&& pairs.elements[0].type !== 'SpreadElement'
-				)) {
+				if (!(pairs?.type === 'ArrayExpression'
+					&& pairs.elements[0]) || pairs.elements[0].type === 'SpreadElement') {
 					continue;
 				}
 

package/rules/no-typeof-undefined.js

@@ -1,6 +1,6 @@
 import {isLiteral} from './ast/index.js';
 import {
-	addParenthesizesToReturnOrThrowExpression,
+	addParenthesesToReturnOrThrowExpression,
 	removeSpacesAfter,
 } from './fix/index.js';
 import {
@@ -74,7 +74,7 @@ const create = context => {
 				&& !isParenthesized(binaryExpression, context)
 				&& !isParenthesized(typeofNode, context)
 			) {
-				yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+				yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 				return;
 			}