eslint-plugin-unicorn 67.0.0 → 69.0.0

package/rules/no-break-in-nested-loop.js

@@ -1,8 +1,10 @@
 import {isFunction, isLoop, loopTypes} from './ast/index.js';
 
 const MESSAGE_ID = 'no-break-in-nested-loop';
+const SWITCH_CONTINUE_MESSAGE_ID = 'switch-continue';
 const messages = {
 	[MESSAGE_ID]: 'Move this nested loop or switch into a function instead of using `{{keyword}}` here.',
+	[SWITCH_CONTINUE_MESSAGE_ID]: 'An unlabeled `continue` inside a `switch` continues the surrounding loop, not the next `case`. Use a labeled `continue` if that is intentional.',
 };
 
 const controlFlowNodeTypes = new Set([
@@ -56,6 +58,30 @@ function isNestedControlFlowStatement(node, sourceCode) {
 	return false;
 }
 
+function isContinueInSwitchInsideLoop(node, sourceCode) {
+	if (node.type !== 'ContinueStatement' || node.label) {
+		return false;
+	}
+
+	let hasSwitch = false;
+
+	for (const ancestor of sourceCode.getAncestors(node).toReversed()) {
+		if (isFunction(ancestor)) {
+			return false;
+		}
+
+		if (isLoop(ancestor)) {
+			return hasSwitch;
+		}
+
+		if (ancestor.type === 'SwitchStatement') {
+			hasSwitch = true;
+		}
+	}
+
+	return false;
+}
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;
@@ -68,6 +94,13 @@ const create = context => {
 			return;
 		}
 
+		if (isContinueInSwitchInsideLoop(node, sourceCode)) {
+			return {
+				node,
+				messageId: SWITCH_CONTINUE_MESSAGE_ID,
+			};
+		}
+
 		return {
 			node,
 			messageId: MESSAGE_ID,

package/rules/no-chained-comparison.js

@@ -0,0 +1,116 @@
+import {hasSideEffect} from '@eslint-community/eslint-utils';
+import {getParenthesizedText, isParenthesized, isBoolean} from './utils/index.js';
+
+const MESSAGE_ID_ERROR = 'no-chained-comparison/error';
+const MESSAGE_ID_SUGGESTION = 'no-chained-comparison/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Comparison operators cannot be chained. The inner comparison evaluates to a boolean, which is then compared instead of the operands.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace with `{{replacement}}`.',
+};
+
+const orderingOperators = new Set(['<', '>', '<=', '>=']);
+const equalityOperators = new Set(['===', '!==', '==', '!=']);
+const comparisonOperators = orderingOperators.union(equalityOperators);
+
+const isComparison = node => node.type === 'BinaryExpression' && comparisonOperators.has(node.operator);
+const isBooleanLiteral = node => node.type === 'Literal' && typeof node.value === 'boolean';
+
+// The `&&` rewrite is a `LogicalExpression`, which binds looser than any comparison. It can only
+// replace `node` where a surrounding operator won't recapture it: at the top of an expression or
+// when already parenthesized, but not as an operand of another binary expression (`foo === a < b < c`)
+// or mixed with `??` (which is a syntax error).
+const isSafeForLogicalReplacement = (node, context) => {
+	if (isParenthesized(node, context)) {
+		return true;
+	}
+
+	const {parent} = node;
+	return parent.type !== 'BinaryExpression'
+		&& !(parent.type === 'LogicalExpression' && parent.operator === '??');
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	context.on('BinaryExpression', node => {
+		if (!comparisonOperators.has(node.operator)) {
+			return;
+		}
+
+		const nested = isComparison(node.left) ? node.left : node.right;
+		if (!isComparison(nested)) {
+			return;
+		}
+
+		const isNestedOnLeft = nested === node.left;
+		const sibling = isNestedOnLeft ? node.right : node.left;
+
+		// For equality operators, comparing a comparison result against another boolean value
+		// (`(a > 0) === (b > 0)`, `(a < b) === true`, `(a > 0) !== Boolean(b)`) is an intentional
+		// boolean comparison, not a chained comparison.
+		if (
+			equalityOperators.has(node.operator)
+			&& isBoolean(sibling, context)
+		) {
+			return;
+		}
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID_ERROR,
+		};
+
+		// Only the canonical left-associative chain `(a OP1 b) OP2 c` has an unambiguous
+		// `a OP1 b && b OP2 c` rewrite. The `&&` rewrite only reflects a plausible intent for a
+		// real ordering or equality chain, so the inner and outer operators must be the same kind
+		// and the outer operand must not be a boolean literal (`(a < b) < true` is not a range
+		// check). The middle operand `b` is duplicated, so the rewrite must also be free of side
+		// effects and comments.
+		const isSameOperatorKind = orderingOperators.has(nested.operator) === orderingOperators.has(node.operator);
+		const isPlausibleChain = isSameOperatorKind && !isBooleanLiteral(node.right);
+		if (
+			isNestedOnLeft
+			&& isPlausibleChain
+			// Both outer operands must be plain. A comparison at either end (`(a < b) < (c < d)`
+			// or a deeper chain `a < b < c < d`) has no single unambiguous `&&` rewrite.
+			&& !isComparison(node.right)
+			&& !isComparison(nested.left)
+			&& isSafeForLogicalReplacement(node, context)
+			&& !hasSideEffect(nested.right, sourceCode)
+			&& sourceCode.getCommentsInside(node).length === 0
+		) {
+			const replacement = `${sourceCode.getText(node.left)} && ${getParenthesizedText(nested.right, context)} ${node.operator} ${getParenthesizedText(node.right, context)}`;
+
+			problem.suggest = [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					data: {replacement},
+					/** @param {import('eslint').Rule.RuleFixer} fixer */
+					fix: fixer => fixer.replaceText(node, replacement),
+				},
+			];
+		}
+
+		return problem;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow chained comparisons such as `a < b < c`.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-collection-bracket-access.js

@@ -0,0 +1,165 @@
+import {getStaticValue} from '@eslint-community/eslint-utils';
+import {
+	isMap,
+	isSet,
+	isWeakMap,
+	isWeakSet,
+	isLeftHandSide,
+	getParenthesizedText,
+} from './utils/index.js';
+
+/**
+@import * as ESLint from 'eslint';
+*/
+
+const MESSAGE_ID_READ = 'no-collection-bracket-access/read';
+const MESSAGE_ID_WRITE = 'no-collection-bracket-access/write';
+const MESSAGE_ID_DELETE = 'no-collection-bracket-access/delete';
+const MESSAGE_ID_SUGGESTION_SET = 'no-collection-bracket-access/suggestion-set';
+const MESSAGE_ID_SUGGESTION_DELETE = 'no-collection-bracket-access/suggestion-delete';
+const messages = {
+	[MESSAGE_ID_READ]: 'Do not read from a `{{type}}` using bracket notation.',
+	[MESSAGE_ID_WRITE]: 'Do not write to a `{{type}}` using bracket notation.',
+	[MESSAGE_ID_DELETE]: 'Do not delete from a `{{type}}` using bracket notation.',
+	[MESSAGE_ID_SUGGESTION_SET]: 'Switch to `{{type}}#set()`.',
+	[MESSAGE_ID_SUGGESTION_DELETE]: 'Switch to `{{type}}#delete()`.',
+};
+
+const collectionTypes = [
+	{
+		name: 'Map',
+		is: isMap,
+		prototype: Map.prototype,
+		hasSetMethod: true,
+	},
+	{
+		name: 'WeakMap',
+		is: isWeakMap,
+		prototype: WeakMap.prototype,
+		hasSetMethod: true,
+	},
+	{
+		name: 'Set',
+		is: isSet,
+		prototype: Set.prototype,
+		hasSetMethod: false,
+	},
+	{
+		name: 'WeakSet',
+		is: isWeakSet,
+		prototype: WeakSet.prototype,
+		hasSetMethod: false,
+	},
+];
+
+// Only `Identifier`/`ThisExpression`/`MemberExpression` receivers can be placed before
+// `.method(…)` without parentheses, so suggestions are limited to them.
+const simpleObjectTypes = new Set(['Identifier', 'ThisExpression', 'MemberExpression']);
+
+function getProblem(node, collection, context) {
+	const {sourceCode} = context;
+	const {name: type} = collection;
+
+	// An optional access (`map?.['foo']`) wraps the member in a `ChainExpression`.
+	const outerNode = node.parent.type === 'ChainExpression' ? node.parent : node;
+	const {parent} = outerNode;
+	const object = getParenthesizedText(node.object, context);
+	const key = getParenthesizedText(node.property, context);
+
+	let messageId = MESSAGE_ID_READ;
+	let suggestionMessageId;
+	let replacement;
+	if (
+		parent.type === 'UnaryExpression'
+		&& parent.operator === 'delete'
+		&& parent.argument === outerNode
+	) {
+		messageId = MESSAGE_ID_DELETE;
+		suggestionMessageId = MESSAGE_ID_SUGGESTION_DELETE;
+		replacement = `${object}.delete(${key})`;
+	} else if (
+		isLeftHandSide(node)
+		|| (
+			(parent.type === 'ForOfStatement' || parent.type === 'ForInStatement')
+			&& parent.left === outerNode
+		)
+	) {
+		messageId = MESSAGE_ID_WRITE;
+		if (
+			collection.hasSetMethod
+			&& parent.type === 'AssignmentExpression'
+			&& parent.operator === '='
+			&& parent.left === node
+		) {
+			suggestionMessageId = MESSAGE_ID_SUGGESTION_SET;
+			replacement = `${object}.set(${key}, ${getParenthesizedText(parent.right, context)})`;
+		}
+	}
+
+	const problem = {node, messageId, data: {type}};
+
+	// Only suggest for the simple, statement-level case, to avoid changing the value of the
+	// surrounding expression, dropping comments, or needing to parenthesize the receiver.
+	if (
+		suggestionMessageId
+		&& !node.optional
+		&& simpleObjectTypes.has(node.object.type)
+		&& parent.parent.type === 'ExpressionStatement'
+		&& sourceCode.getCommentsInside(parent).length === 0
+	) {
+		problem.suggest = [
+			{
+				messageId: suggestionMessageId,
+				data: {type},
+				fix: fixer => fixer.replaceText(parent, replacement),
+			},
+		];
+	}
+
+	return problem;
+}
+
+/** @param {ESLint.Rule.RuleContext} context */
+const create = context => {
+	context.on('MemberExpression', node => {
+		if (!node.computed) {
+			return;
+		}
+
+		const collection = collectionTypes.find(({is}) => is(node.object, context));
+		if (!collection) {
+			return;
+		}
+
+		// Allow accessing a real member, including `Symbol` ones like `map[Symbol.iterator]`.
+		const staticResult = getStaticValue(node.property, context.sourceCode.getScope(node.property));
+		if (
+			staticResult
+			&& (typeof staticResult.value === 'string' || typeof staticResult.value === 'symbol')
+			&& Reflect.has(collection.prototype, staticResult.value)
+		) {
+			return;
+		}
+
+		return getProblem(node, collection, context);
+	});
+};
+
+/** @type {ESLint.Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow accessing `Map`, `Set`, `WeakMap`, and `WeakSet` entries with bracket notation.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-computed-property-existence-check.js

@@ -1,6 +1,7 @@
 import {
 	getParenthesizedText,
 	hasOptionalChainElement,
+	isBoolean,
 	isBooleanExpression,
 	isControlFlowTest,
 	wouldRemoveComments,
@@ -120,6 +121,11 @@ const create = context => {
 			return;
 		}
 
+		// A property whose value type is a known boolean is a value read, not an existence check (and `no-unnecessary-boolean-comparison` may rewrite a comparison into this form).
+		if (isBoolean(node, context)) {
+			return;
+		}
+
 		return {
 			node,
 			messageId: MESSAGE_ID,

package/rules/no-confusing-array-splice.js

@@ -1,5 +1,5 @@
-import {isMethodCall, isNumericLiteral} from './ast/index.js';
-import {getParenthesizedText} from './utils/index.js';
+import {isMethodCall} from './ast/index.js';
+import {getParenthesizedText, getStaticNumberValue} from './utils/index.js';
 import {isSame, unwrapExpression} from './utils/comparison.js';
 
 const REPLACE_ONE_ELEMENT = 'replace-one-element';
@@ -13,25 +13,6 @@ const messages = {
 	[SUGGESTION_INSERT_AT_NEGATIVE_ONE]: 'Resolve the insertion index explicitly.',
 };
 
-function getStaticNumberValue(node) {
-	node = unwrapExpression(node);
-
-	if (isNumericLiteral(node)) {
-		return node.value;
-	}
-
-	if (
-		node.type === 'UnaryExpression'
-		&& (node.operator === '+' || node.operator === '-')
-	) {
-		const value = getStaticNumberValue(node.argument);
-
-		if (typeof value === 'number') {
-			return node.operator === '-' ? -value : value;
-		}
-	}
-}
-
 const isNegativeStaticIndex = node => Math.trunc(getStaticNumberValue(node)) < 0;
 
 function getNormalizedDeleteCountValue(node) {

package/rules/no-confusing-array-with.js

@@ -1,4 +1,5 @@
-import {isMethodCall, isNumericLiteral} from './ast/index.js';
+import {isMethodCall} from './ast/index.js';
+import {getStaticNumberValue} from './utils/index.js';
 import {isSame, unwrapExpression} from './utils/comparison.js';
 
 const MESSAGE_ID_NEGATIVE_INDEX = 'negative-index';
@@ -13,25 +14,6 @@ const messages = {
 @import * as ESLint from 'eslint';
 */
 
-function getStaticNumberValue(node) {
-	node = unwrapExpression(node);
-
-	if (isNumericLiteral(node)) {
-		return node.value;
-	}
-
-	if (
-		node.type === 'UnaryExpression'
-		&& (node.operator === '+' || node.operator === '-')
-	) {
-		const value = getStaticNumberValue(node.argument);
-
-		if (typeof value === 'number') {
-			return node.operator === '-' ? -value : value;
-		}
-	}
-}
-
 const isNegativeStaticIndex = node => Math.trunc(getStaticNumberValue(node)) < 0;
 
 function isLengthMemberExpressionFor(node, object) {

package/rules/no-constant-zero-expression.js

@@ -0,0 +1,91 @@
+import {getStaticValue} from '@eslint-community/eslint-utils';
+import {isLiteral} from './ast/index.js';
+
+const MESSAGE_ID_ERROR = 'no-constant-zero-expression/error';
+const MESSAGE_ID_SUGGESTION = 'no-constant-zero-expression/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'This operation always evaluates to `0` (or `-0`/`NaN`), which is likely a mistake.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace this expression with `0`.',
+};
+
+const isZero = node => isLiteral(node, 0);
+
+/**
+Check if a binary expression has a `0` operand that dominates the result.
+
+`x * 0` / `0 * x` and `x & 0` / `0 & x` are dominated by a `0` on either side. `0 / x` is dominated only when the `0` is on the left, since `x / 0` is `Infinity`/`NaN`.
+
+@param {import('estree').BinaryExpression} node
+@returns {boolean}
+*/
+const isErasedToZero = node => {
+	switch (node.operator) {
+		case '*':
+		case '&': {
+			return isZero(node.left) || isZero(node.right);
+		}
+
+		case '/': {
+			return isZero(node.left);
+		}
+
+		default: {
+			return false;
+		}
+	}
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	context.on('BinaryExpression', node => {
+		if (!isErasedToZero(node)) {
+			return;
+		}
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID_ERROR,
+		};
+
+		// Only suggest replacing with `0` when the whole expression provably folds to exactly `+0`.
+		// `getStaticValue` resolves only side-effect-free constants, and `Object.is(…, 0)` excludes
+		// `-0` (e.g. `-5 * 0`, `0 / -5`) and `NaN` (e.g. `0 / 0`), so those are reported without a suggestion.
+		const staticValue = getStaticValue(node, sourceCode.getScope(node));
+		if (
+			staticValue
+			&& Object.is(staticValue.value, 0)
+			&& sourceCode.getCommentsInside(node).length === 0
+		) {
+			problem.suggest = [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					/** @param {import('eslint').Rule.RuleFixer} fixer */
+					fix: fixer => fixer.replaceText(node, '0'),
+				},
+			];
+		}
+
+		return problem;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow arithmetic and bitwise operations that always evaluate to `0`.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-declarations-before-early-exit.js

@@ -1,5 +1,5 @@
 import {isCommentToken, hasSideEffect} from '@eslint-community/eslint-utils';
-import {getReferences} from './utils/index.js';
+import {containsSuspensionPoint, getReferences, trackBranchExits} from './utils/index.js';
 
 const MESSAGE_ID = 'no-declarations-before-early-exit';
 const messages = {
@@ -10,40 +10,17 @@ const isLetOrConstDeclaration = node =>
 	node.type === 'VariableDeclaration'
 	&& (node.kind === 'let' || node.kind === 'const');
 
-const getLastStatement = node => {
-	if (node.type !== 'BlockStatement') {
-		return node;
-	}
-
-	return node.body.at(-1);
-};
-
-const isEarlyExitStatement = node =>
-	node?.type === 'ReturnStatement'
-	|| node?.type === 'ThrowStatement'
-	|| node?.type === 'BreakStatement'
-	|| node?.type === 'ContinueStatement';
-
-function branchDefinitelyExits(node) {
-	const statement = getLastStatement(node);
-	if (isEarlyExitStatement(statement)) {
-		return true;
-	}
-
-	return statement?.type === 'IfStatement'
-		&& statement.alternate
-		&& branchDefinitelyExits(statement.consequent)
-		&& branchDefinitelyExits(statement.alternate);
-}
-
-function isGuardStatement(node) {
+// A guard is an `if` statement where exactly one branch always exits, so control after it is
+// conditional. `branchAlwaysExits` uses code path analysis, so guards whose exiting branch ends
+// in an exhaustive `switch`, `try`/`finally`, or other complex control flow are detected too.
+function isGuardStatement(node, branchAlwaysExits) {
 	if (node.type !== 'IfStatement') {
 		return false;
 	}
 
-	const consequentExits = branchDefinitelyExits(node.consequent);
-	const alternateExits = node.alternate && branchDefinitelyExits(node.alternate);
-	return consequentExits !== Boolean(alternateExits);
+	const consequentExits = branchAlwaysExits(node.consequent);
+	const alternateExits = Boolean(node.alternate) && branchAlwaysExits(node.alternate);
+	return consequentExits !== alternateExits;
 }
 
 // https://github.com/facebook/react/blob/main/packages/eslint-plugin-react-hooks/src/rules/RulesOfHooks.ts
@@ -161,6 +138,11 @@ function getProblem({
 		return;
 	}
 
+	// Moving a declaration whose initializer suspends (`await`/`yield`) would reorder the guard's condition across the suspension point, changing observable timing.
+	if (declarator.init && containsSuspensionPoint(declarator.init, sourceCode.visitorKeys)) {
+		return;
+	}
+
 	if (
 		guardIndex > declarationIndex + 1
 		&& !isSimpleInitializer(declarator.init)
@@ -213,7 +195,12 @@ function getProblem({
 	return problem;
 }
 
-function * getStatementListProblems(sourceCode, statements) {
+function * getStatementListProblems(sourceCode, statements, branchAlwaysExits) {
+	// Resolve each statement to itself when it is a guard (or `undefined` otherwise) at most
+	// once per list, instead of re-running the code-path-analysis check for every
+	// declaration/statement pair.
+	let guards;
+
 	for (const [declarationIndex, declaration] of statements.entries()) {
 		if (
 			!isLetOrConstDeclaration(declaration)
@@ -222,8 +209,11 @@ function * getStatementListProblems(sourceCode, statements) {
 			continue;
 		}
 
-		for (const [guardIndex, guardStatement] of statements.entries()) {
-			if (guardIndex <= declarationIndex || !isGuardStatement(guardStatement)) {
+		guards ??= statements.map(statement => isGuardStatement(statement, branchAlwaysExits) ? statement : undefined);
+
+		for (let guardIndex = declarationIndex + 1; guardIndex < statements.length; guardIndex++) {
+			const guardStatement = guards[guardIndex];
+			if (!guardStatement) {
 				continue;
 			}
 
@@ -250,9 +240,12 @@ function * getStatementListProblems(sourceCode, statements) {
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;
+	const branchAlwaysExits = trackBranchExits(context);
 
-	context.on('Program', node => getStatementListProblems(sourceCode, node.body));
-	context.on('BlockStatement', node => getStatementListProblems(sourceCode, node.body));
+	// Run on exit so that all nested `if` statements have been visited and their branch exit
+	// information is available before scanning each statement list.
+	context.onExit('Program', node => getStatementListProblems(sourceCode, node.body, branchAlwaysExits));
+	context.onExit('BlockStatement', node => getStatementListProblems(sourceCode, node.body, branchAlwaysExits));
 };
 
 /** @type {import('eslint').Rule.RuleModule} */