eslint-plugin-unicorn 69.0.0 → 71.0.0

package/rules/no-unused-properties.js

@@ -65,7 +65,6 @@ const getReferenceParent = referenceNode => {
 	return referenceNode.parent;
 };
 
-// eslint-disable-next-line unicorn/name-replacements
 const specialProtoPropertyKey = {
 	type: 'Identifier',
 	name: '__proto__',

package/rules/no-useless-coercion.js

@@ -1,3 +1,4 @@
+import {isEmptyStringLiteral} from './ast/index.js';
 import {
 	isBoolean,
 	isString,
@@ -25,8 +26,6 @@ const coercions = new Map([
 	['Number', {type: 'number', isType: (node, context) => isNumber(node, context.sourceCode.getScope(node))}],
 ]);
 
-const isEmptyStringLiteral = node => node.type === 'Literal' && node.value === '';
-
 /** @param {ESLint.Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;

package/rules/no-useless-else.js

@@ -1,6 +1,8 @@
+import {isMethodCall} from './ast/index.js';
 import {
 	hasCommentInRange,
 	hasDirectBlockScopedDeclaration,
+	isGlobalIdentifier,
 	needsSemicolon,
 	trackBranchExits,
 } from './utils/index.js';
@@ -42,6 +44,35 @@ const isJsxChildTextToken = (token, sourceCode) =>
 	token.type === 'JSXText'
 	&& sourceCode.getNodeByRangeIndex(sourceCode.getRange(token)[0]).type === 'JSXText';
 
+const isProcessExitCall = (node, context) =>
+	isMethodCall(node, {
+		object: 'process',
+		method: 'exit',
+		optionalCall: false,
+		optionalMember: false,
+	})
+	&& isGlobalIdentifier(node.callee.object, context);
+
+const isProcessExitStatement = (node, context) =>
+	node.type === 'ExpressionStatement'
+	&& isProcessExitCall(node.expression, context);
+
+function branchExits(branch, context, branchAlwaysExits) {
+	if (branchAlwaysExits(branch) || isProcessExitStatement(branch, context)) {
+		return true;
+	}
+
+	if (branch.type === 'BlockStatement') {
+		const lastStatement = branch.body.at(-1);
+		return Boolean(lastStatement && branchExits(lastStatement, context, branchAlwaysExits));
+	}
+
+	return branch.type === 'IfStatement'
+		&& branch.alternate
+		&& branchExits(branch.consequent, context, branchAlwaysExits)
+		&& branchExits(branch.alternate, context, branchAlwaysExits);
+}
+
 // A multiline token's internal whitespace can be meaningful, so it can't be safely reindented.
 // JSX child text is safe because JSX collapses line-leading and line-trailing whitespace at compile time.
 const hasReindentUnsafeMultilineToken = (node, context) => {
@@ -192,7 +223,7 @@ const fix = (ifStatement, context) => fixer => {
 /** @param {ESLint.Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;
-	const branchAlwaysExits = trackBranchExits(context);
+	const branchAlwaysExits = trackBranchExits(context, branch => branchExits(branch, context, branchAlwaysExits));
 
 	context.onExit('IfStatement', ifStatement => {
 		if (!(

package/rules/no-useless-iterator-to-array.js

@@ -1,4 +1,5 @@
 import typedArray from './shared/typed-array.js';
+import {unwrapExpression} from './shared/iterator-helpers.js';
 import {removeMethodCall} from './fix/index.js';
 import {
 	isNewExpression,
@@ -33,9 +34,7 @@ const callbackOnlyIteratorMethods = [
 	'some',
 ];
 
-// `reduce` — both Array and Iterator accept (callback, initialValue),
-// but Array.reduce without initialValue uses the first element while
-// Iterator.reduce without initialValue throws.
+// `reduce` — both Array and Iterator accept (callback, initialValue).
 const reduceMethod = 'reduce';
 
 const isToArrayCall = node => isMethodCall(node, {
@@ -81,13 +80,17 @@ const getArrayFromProblem = (node, context) => {
 	}
 
 	const toArrayCall = node.arguments[0];
-	const fix = getRemoveToArrayFix(toArrayCall, context);
+	const fix = node.arguments.length === 1 ? getRemoveToArrayFix(toArrayCall, context) : undefined;
+	const suggestion = node.arguments.length > 1
+		? getRemoveToArraySuggestion(toArrayCall, context, MESSAGE_ID_SUGGESTION_ITERABLE_ACCEPTING)
+		: undefined;
 
 	return {
 		node: toArrayCall.callee.property,
 		messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
 		data: {description: `${node.callee.object.name}.${node.callee.property.name}(…)`},
 		...(fix && {fix}),
+		...(suggestion && {suggest: [suggestion]}),
 	};
 };
 
@@ -106,13 +109,17 @@ const getObjectFromEntriesProblem = (node, context) => {
 	}
 
 	const toArrayCall = node.arguments[0];
-	const fix = getRemoveToArrayFix(toArrayCall, context);
+	const fix = node.arguments.length === 1 ? getRemoveToArrayFix(toArrayCall, context) : undefined;
+	const suggestion = node.arguments.length > 1
+		? getRemoveToArraySuggestion(toArrayCall, context, MESSAGE_ID_SUGGESTION_ITERABLE_ACCEPTING)
+		: undefined;
 
 	return {
 		node: toArrayCall.callee.property,
 		messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
 		data: {description: `${node.callee.object.name}.${node.callee.property.name}(…)`},
 		...(fix && {fix}),
+		...(suggestion && {suggest: [suggestion]}),
 	};
 };
 
@@ -143,6 +150,28 @@ const getPromiseProblem = (node, context) => {
 	};
 };
 
+const canObserveArrayArgument = (callback, arrayParameterIndex, context) => {
+	if (!callback) {
+		return false;
+	}
+
+	callback = unwrapExpression(callback);
+
+	if (
+		callback.type === 'ArrowFunctionExpression'
+		|| callback.type === 'FunctionExpression'
+	) {
+		return callback.params.length > arrayParameterIndex
+			|| callback.params.at(-1)?.type === 'RestElement'
+			|| (
+				callback.type === 'FunctionExpression'
+				&& context.sourceCode.getTokens(callback).some(token => token.type === 'Identifier' && token.value === 'arguments')
+			);
+	}
+
+	return false;
+};
+
 const getIteratorMethodProblem = (node, context) => {
 	if (
 		!(
@@ -154,7 +183,8 @@ const getIteratorMethodProblem = (node, context) => {
 			})
 			|| isMethodCall(node, {
 				method: reduceMethod,
-				argumentsLength: 2,
+				minimumArguments: 1,
+				maximumArguments: 2,
 				optionalCall: false,
 				optionalMember: false,
 			})
@@ -170,15 +200,7 @@ const getIteratorMethodProblem = (node, context) => {
 	const method = node.callee.property.name;
 	const isReduceCall = method === reduceMethod;
 	const arrayParameterIndex = isReduceCall ? 3 : 2;
-	if (
-		callback
-		&& (callback.type === 'ArrowFunctionExpression' || callback.type === 'FunctionExpression')
-		&& (
-			callback.params.length > arrayParameterIndex
-			// A rest parameter can capture the trailing `array` argument too.
-			|| callback.params.at(-1)?.type === 'RestElement'
-		)
-	) {
+	if (canObserveArrayArgument(callback, arrayParameterIndex, context)) {
 		return;
 	}
 
@@ -208,13 +230,17 @@ const create = context => {
 		}
 
 		const toArrayCall = node.arguments[0];
-		const fix = getRemoveToArrayFix(toArrayCall, context);
+		const fix = node.arguments.length === 1 ? getRemoveToArrayFix(toArrayCall, context) : undefined;
+		const suggestion = node.arguments.length > 1
+			? getRemoveToArraySuggestion(toArrayCall, context, MESSAGE_ID_SUGGESTION_ITERABLE_ACCEPTING)
+			: undefined;
 
 		return {
 			node: toArrayCall.callee.property,
 			messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
 			data: {description: `new ${node.callee.name}(…)`},
 			...(fix && {fix}),
+			...(suggestion && {suggest: [suggestion]}),
 		};
 	});
 

package/rules/no-useless-spread.js

@@ -1,6 +1,6 @@
 import {isCommaToken} from '@eslint-community/eslint-utils';
 import typedArray from './shared/typed-array.js';
-import {removeParentheses, fixSpaceAroundKeyword, addParenthesizesToReturnOrThrowExpression} from './fix/index.js';
+import {removeParentheses, fixSpaceAroundKeyword, addParenthesesToReturnOrThrowExpression} from './fix/index.js';
 import {
 	isArray,
 	isKnownNonArray,
@@ -143,7 +143,7 @@ function * unwrapSingleArraySpread(fixer, arrayExpression, context) {
 		&& !isOnSameLine(openingBracketToken, thirdToken, context)
 		&& !isParenthesized(arrayExpression, context)
 	) {
-		yield addParenthesizesToReturnOrThrowExpression(fixer, parent, context);
+		yield addParenthesesToReturnOrThrowExpression(fixer, parent, context);
 		return;
 	}
 

package/rules/no-useless-undefined.js

@@ -410,10 +410,10 @@ const create = context => {
 			return;
 		}
 
-		const accessWhenTestPasses = !isConsequentUndefined;
+		const isAccessWhenTestPasses = !isConsequentUndefined;
 		const testValidity = getIndexedAccessTestValidity(node.test, indexedAccess);
 
-		if (testValidity !== accessWhenTestPasses) {
+		if (testValidity !== isAccessWhenTestPasses) {
 			return;
 		}