eslint-plugin-unicorn 67.0.0 → 69.0.0

package/rules/no-double-comparison.js

@@ -0,0 +1,117 @@
+import {getParenthesizedRange, getParenthesizedText} from './utils/index.js';
+import {
+	comparisonOperators,
+	containsOptionalChain,
+	flipOperator,
+	isSame,
+	unwrapExpression,
+} from './utils/comparison.js';
+
+const MESSAGE_ID = 'no-double-comparison';
+const MESSAGE_ID_SUGGESTION = 'no-double-comparison/suggestion';
+const messages = {
+	[MESSAGE_ID]: 'These comparisons can be simplified to `{{replacement}}`.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace with `{{replacement}}`.',
+};
+
+// Map of `<logical-operator> <comparison operators>` to the combined operator. The two comparison operators are registered in both orders so the lookup is order-independent.
+const reductionKey = (logicalOperator, first, second) => `${logicalOperator} ${first} ${second}`;
+const reductions = new Map();
+for (const [logicalOperator, [first, second], result] of [
+	['||', ['===', '<'], {operator: '<='}],
+	['||', ['===', '>'], {operator: '>='}],
+	['||', ['<', '>'], {operator: '!=='}],
+	['&&', ['<=', '>='], {operator: '==='}],
+	['&&', ['<=', '!=='], {operator: '<'}],
+	['&&', ['>=', '!=='], {operator: '>'}],
+]) {
+	reductions.set(reductionKey(logicalOperator, first, second), result);
+	reductions.set(reductionKey(logicalOperator, second, first), result);
+}
+
+const isComparison = node =>
+	node.type === 'BinaryExpression'
+	&& comparisonOperators.has(node.operator)
+	&& !containsOptionalChain(node);
+
+// Whether a comment falls within an operand, including its surrounding parentheses, since operands are reused with their parentheses.
+const isCommentWithinOperand = (comment, operand, context) => {
+	const {sourceCode} = context;
+	const [commentStart, commentEnd] = sourceCode.getRange(comment);
+	const [operandStart, operandEnd] = getParenthesizedRange(operand, context);
+	return commentStart >= operandStart && commentEnd <= operandEnd;
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	context.on('LogicalExpression', node => {
+		if (node.operator !== '||' && node.operator !== '&&') {
+			return;
+		}
+
+		const left = unwrapExpression(node.left);
+		const right = unwrapExpression(node.right);
+
+		if (!isComparison(left) || !isComparison(right)) {
+			return;
+		}
+
+		// The two comparisons must constrain the same pair of operands. The operands may appear in the same order or flipped; when flipped, normalize the right operator so the lookup and fix use the left comparison's operand order.
+		let rightOperator;
+		if (isSame(left.left, right.left) && isSame(left.right, right.right)) {
+			rightOperator = right.operator;
+		} else if (isSame(left.left, right.right) && isSame(left.right, right.left)) {
+			rightOperator = flipOperator[right.operator];
+		} else {
+			return;
+		}
+
+		const reduction = reductions.get(reductionKey(node.operator, left.operator, rightOperator));
+		if (!reduction) {
+			return;
+		}
+
+		const leftText = getParenthesizedText(left.left, context);
+		const rightText = getParenthesizedText(left.right, context);
+		const replacement = `${leftText} ${reduction.operator} ${rightText}`;
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID,
+			data: {replacement},
+		};
+
+		// Replacing the whole expression reuses only the left comparison's operands, so a comment outside both of them would be dropped.
+		const hasDroppedComment = sourceCode.getCommentsInside(node)
+			.some(comment => !isCommentWithinOperand(comment, left.left, context) && !isCommentWithinOperand(comment, left.right, context));
+		if (hasDroppedComment) {
+			return problem;
+		}
+
+		const fix = fixer => fixer.replaceText(node, replacement);
+		problem.suggest = [{messageId: MESSAGE_ID_SUGGESTION, data: {replacement}, fix}];
+
+		return problem;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow two comparisons of the same operands that can be combined into one.',
+			recommended: 'unopinionated',
+		},
+		hasSuggestions: true,
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-duplicate-if-branches.js

@@ -0,0 +1,143 @@
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+const MESSAGE_ID = 'no-duplicate-if-branches';
+const messages = {
+	[MESSAGE_ID]: 'This branch has the same body as the branch on line {{line}}.',
+};
+
+const isElseIfStatement = node =>
+	node.parent.type === 'IfStatement'
+	&& node.parent.alternate === node;
+
+const getBranchStatements = node => node.type === 'BlockStatement' ? node.body : [node];
+
+const getStatementTokens = (node, sourceCode) => {
+	const tokens = sourceCode.getTokens(node);
+	const lastToken = tokens.at(-1);
+
+	if (lastToken?.type === 'Punctuator' && lastToken.value === ';') {
+		return tokens.slice(0, -1);
+	}
+
+	return tokens;
+};
+
+const areSameTokens = (left, right) =>
+	left.type === right.type
+	&& left.value === right.value;
+
+const areSameBranchBodies = (leftStatements, rightStatements, sourceCode) => {
+	if (leftStatements.length !== rightStatements.length) {
+		return false;
+	}
+
+	let hasTokens = false;
+
+	for (const [statementIndex, leftStatement] of leftStatements.entries()) {
+		const leftTokens = getStatementTokens(leftStatement, sourceCode);
+		const rightTokens = getStatementTokens(rightStatements[statementIndex], sourceCode);
+
+		if (leftTokens.length > 0) {
+			hasTokens = true;
+		}
+
+		if (leftTokens.length !== rightTokens.length) {
+			return false;
+		}
+
+		for (const [tokenIndex, leftToken] of leftTokens.entries()) {
+			if (!areSameTokens(leftToken, rightTokens[tokenIndex])) {
+				return false;
+			}
+		}
+	}
+
+	return hasTokens;
+};
+
+/**
+@param {ESTree.IfStatement} ifStatement
+@returns {Array<{body: ESTree.Statement, statements: ESTree.Statement[]}>}
+*/
+function getBranches(ifStatement) {
+	const branches = [];
+	let node = ifStatement;
+
+	while (node) {
+		branches.push({
+			body: node.consequent,
+			statements: getBranchStatements(node.consequent),
+		});
+
+		if (node.alternate?.type !== 'IfStatement') {
+			if (node.alternate) {
+				branches.push({
+					body: node.alternate,
+					statements: getBranchStatements(node.alternate),
+				});
+			}
+
+			break;
+		}
+
+		node = node.alternate;
+	}
+
+	return branches;
+}
+
+/**
+@param {ESTree.IfStatement} ifStatement
+@param {ESLint.Rule.RuleContext} context
+@returns {Generator<ESLint.Rule.ReportDescriptor>}
+*/
+function * getProblems(ifStatement, context) {
+	if (isElseIfStatement(ifStatement)) {
+		return;
+	}
+
+	const {sourceCode} = context;
+	const branches = getBranches(ifStatement);
+
+	for (let index = 1; index < branches.length; index++) {
+		const branch = branches[index];
+		const previousBranch = branches[index - 1];
+
+		if (areSameBranchBodies(branch.statements, previousBranch.statements, sourceCode)) {
+			yield {
+				node: branch.body,
+				messageId: MESSAGE_ID,
+				data: {
+					line: String(sourceCode.getLoc(previousBranch.body).start.line),
+				},
+			};
+		}
+	}
+}
+
+/** @param {ESLint.Rule.RuleContext} context */
+const create = context => {
+	context.on('IfStatement', ifStatement => getProblems(ifStatement, context));
+};
+
+/** @type {ESLint.Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow duplicate adjacent branches in if chains.',
+			recommended: true,
+		},
+		schema: [],
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-duplicate-logical-operands.js

@@ -0,0 +1,151 @@
+import {getParenthesizedRange, getParenthesizedText} from './utils/index.js';
+import {
+	containsOptionalChain,
+	isSame,
+	unwrapExpression,
+} from './utils/comparison.js';
+
+/**
+@import * as ESLint from 'eslint';
+*/
+
+const MESSAGE_ID = 'no-duplicate-logical-operands';
+const MESSAGE_ID_SUGGESTION = 'no-duplicate-logical-operands/suggestion';
+const messages = {
+	[MESSAGE_ID]: 'This operand duplicates the left operand.',
+	[MESSAGE_ID_SUGGESTION]: 'Remove the duplicate operand.',
+};
+
+const simpleComputedPropertyTypes = new Set(['Identifier', 'ThisExpression', 'Literal']);
+const safelyAutofixableReferenceTypes = new Set(['Identifier', 'ThisExpression']);
+
+const isSimpleComputedProperty = node => {
+	node = unwrapExpression(node);
+
+	return simpleComputedPropertyTypes.has(node.type);
+};
+
+const isSimpleReference = node => {
+	node = unwrapExpression(node);
+
+	if (containsOptionalChain(node)) {
+		return false;
+	}
+
+	switch (node.type) {
+		case 'Identifier':
+		case 'Super':
+		case 'ThisExpression': {
+			return true;
+		}
+
+		case 'MemberExpression': {
+			return isSimpleReference(node.object)
+				&& (!node.computed || isSimpleComputedProperty(node.property));
+		}
+
+		default: {
+			return false;
+		}
+	}
+};
+
+const isSafelyAutofixableReference = node => safelyAutofixableReferenceTypes.has(node.type);
+
+const isInsideWithStatement = node => {
+	for (let current = node.parent; current; current = current.parent) {
+		if (current.type === 'WithStatement') {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+const isCommentInsideOperand = (comment, operand, context) => {
+	const [commentStart, commentEnd] = context.sourceCode.getRange(comment);
+	const [operandStart, operandEnd] = getParenthesizedRange(operand, context);
+	return commentStart >= operandStart && commentEnd <= operandEnd;
+};
+
+const canReplaceWithoutDroppingComments = (node, operand, context) =>
+	context.sourceCode.getCommentsInside(node).every(comment => isCommentInsideOperand(comment, operand, context));
+
+const getAdjacentLeftOperand = node => (
+	node.left.type === 'LogicalExpression' && node.left.operator === node.operator
+		? node.left.right
+		: node.left
+);
+
+/** @param {ESLint.Rule.RuleContext} context */
+const create = context => {
+	context.on('LogicalExpression', node => {
+		if (node.operator !== '&&' && node.operator !== '||') {
+			return;
+		}
+
+		const adjacentLeftOperand = getAdjacentLeftOperand(node);
+
+		if (
+			isInsideWithStatement(node)
+			|| !isSimpleReference(adjacentLeftOperand)
+			|| !isSimpleReference(node.right)
+			|| !isSame(adjacentLeftOperand, node.right)
+		) {
+			return;
+		}
+
+		const problem = {
+			node: node.right,
+			messageId: MESSAGE_ID,
+		};
+
+		if (!canReplaceWithoutDroppingComments(node, node.left, context)) {
+			return problem;
+		}
+
+		const replacement = getParenthesizedText(node.left, context);
+		const fix = fixer => fixer.replaceText(node, replacement);
+
+		if (
+			isSafelyAutofixableReference(adjacentLeftOperand)
+			&& isSafelyAutofixableReference(node.right)
+		) {
+			return {
+				...problem,
+				fix,
+			};
+		}
+
+		return {
+			...problem,
+			suggest: [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					fix,
+				},
+			],
+		};
+	});
+};
+
+/** @type {ESLint.Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow adjacent duplicate operands in logical expressions.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema: [],
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-for-each.js

@@ -189,11 +189,7 @@ function getFixFunction(callExpression, functionInfo, context) {
 			return false;
 		}
 
-		if (callback.body.type !== 'BlockStatement') {
-			return false;
-		}
-
-		return true;
+		return callback.body.type === 'BlockStatement';
 	};
 
 	function * removeCallbackParentheses(fixer) {
@@ -375,11 +371,7 @@ function isFixable(callExpression, {scope, functionInfo, allIdentifiers, sourceC
 		return false;
 	}
 
-	if (isFunctionSelfUsedInside(callback, callbackScope)) {
-		return false;
-	}
-
-	return true;
+	return !isFunctionSelfUsedInside(callback, callbackScope);
 }
 
 const ignoredObjects = [
@@ -443,13 +435,20 @@ const create = context => {
 	});
 
 	context.on('CallExpression', node => {
-		const scope = sourceCode.getScope(node);
+		// Check the cheap method-call shape before resolving scope, so the scope lookup
+		// runs only for actual `.forEach()` calls.
 		if (
 			!isMethodCall(node, {
 				method: 'forEach',
 			})
 			|| isNodeMatches(node.callee.object, ignoredObjects)
-			|| isStrictCallbagBasicsNamespace(node.callee.object, scope)
+		) {
+			return;
+		}
+
+		const scope = sourceCode.getScope(node);
+		if (
+			isStrictCallbagBasicsNamespace(node.callee.object, scope)
 			|| shouldSkipKnownNonArrayReceiver(node.callee.object, context)
 		) {
 			return;

package/rules/no-for-loop.js

@@ -594,11 +594,7 @@ const isOnlyArrayOfIndexVariableRead = (arrayReferences, arrayVariable, indexVar
 		return false;
 	}
 
-	if (isMemberExpressionChanged(node)) {
-		return false;
-	}
-
-	return true;
+	return !isMemberExpressionChanged(node);
 });
 
 const getRemovalRange = (node, sourceCode) => {
@@ -728,11 +724,7 @@ const isIndexVariableUsedElsewhereInTheLoopBody = (indexVariable, bodyScope, arr
 			return true;
 		}
 
-		if (node.object.name !== arrayIdentifierName) {
-			return true;
-		}
-
-		return false;
+		return node.object.name !== arrayIdentifierName;
 	});
 
 	return referencesOtherThanArrayAccess.length > 0;
@@ -854,11 +846,7 @@ const create = context => {
 		const elementReference = arrayReferences.find(reference => {
 			const node = reference.identifier.parent;
 
-			if (node.parent.type !== 'VariableDeclarator') {
-				return false;
-			}
-
-			return true;
+			return node.parent.type === 'VariableDeclarator';
 		});
 		const elementNode = elementReference?.identifier.parent.parent;
 		const elementIdentifierName = elementNode?.id.name;

package/rules/no-impossible-length-comparison.js

@@ -0,0 +1,166 @@
+import {getStaticValue} from '@eslint-community/eslint-utils';
+import {
+	hasOptionalChainElement,
+	hasSameObjectShapePropertyCheck,
+	isKnownNonCollectionLengthOrSize,
+	isLengthOrSizeMemberExpression,
+	unwrapTypeScriptExpression,
+} from './utils/index.js';
+
+const MESSAGE_ID = 'no-impossible-length-comparison';
+const messages = {
+	[MESSAGE_ID]: 'This comparison is always {{result}} because `.{{property}}` is always a non-negative integer.',
+};
+
+const flipOperator = {
+	'<': '>',
+	'<=': '>=',
+	'>': '<',
+	'>=': '<=',
+	'===': '===',
+	'!==': '!==',
+	'==': '==',
+	'!=': '!=',
+};
+
+function getComparisonSubject(node, context) {
+	const left = unwrapTypeScriptExpression(node.left);
+	const right = unwrapTypeScriptExpression(node.right);
+
+	if (isLengthOrSizeMemberExpression(left)) {
+		return {
+			memberExpression: left,
+			operator: node.operator,
+			value: getStaticValue(right, context.sourceCode.getScope(right))?.value,
+		};
+	}
+
+	if (isLengthOrSizeMemberExpression(right)) {
+		return {
+			memberExpression: right,
+			operator: flipOperator[node.operator],
+			value: getStaticValue(left, context.sourceCode.getScope(left))?.value,
+		};
+	}
+}
+
+function getConstantResult({operator, value}) {
+	if (
+		typeof value !== 'number'
+		|| !Number.isFinite(value)
+	) {
+		return;
+	}
+
+	switch (operator) {
+		case '<': {
+			return value <= 0 ? false : undefined;
+		}
+
+		case '<=': {
+			return value < 0 ? false : undefined;
+		}
+
+		case '>': {
+			return value < 0 ? true : undefined;
+		}
+
+		case '>=': {
+			return value <= 0 ? true : undefined;
+		}
+
+		case '===':
+		case '==': {
+			return value < 0 ? false : undefined;
+		}
+
+		case '!==':
+		case '!=': {
+			return value < 0 ? true : undefined;
+		}
+
+		default:
+	}
+}
+
+function hasOptionalChain(node) {
+	node = unwrapTypeScriptExpression(node);
+	if (node.type === 'ChainExpression' || hasOptionalChainElement(node)) {
+		return true;
+	}
+
+	if (node.type === 'MemberExpression') {
+		return hasOptionalChain(node.object);
+	}
+
+	if (node.type === 'CallExpression') {
+		return hasOptionalChain(node.callee);
+	}
+
+	return false;
+}
+
+function isOptionalChainReceiver(memberExpression) {
+	return hasOptionalChain(memberExpression.object);
+}
+
+function isCustomClassReceiver(memberExpression) {
+	const receiver = unwrapTypeScriptExpression(memberExpression.object);
+	return receiver.type === 'ThisExpression' || receiver.type === 'Super';
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('BinaryExpression', node => {
+		if (!Object.hasOwn(flipOperator, node.operator)) {
+			return;
+		}
+
+		const comparison = getComparisonSubject(node, context);
+		if (!comparison) {
+			return;
+		}
+
+		const {memberExpression} = comparison;
+		if (
+			isCustomClassReceiver(memberExpression)
+			|| isOptionalChainReceiver(memberExpression)
+			|| isKnownNonCollectionLengthOrSize(memberExpression, context)
+			|| hasSameObjectShapePropertyCheck({node, lengthOrSizeNode: memberExpression})
+		) {
+			return;
+		}
+
+		const result = getConstantResult(comparison);
+		if (result === undefined) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			data: {
+				property: memberExpression.property.name,
+				result: String(result),
+			},
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow impossible comparisons against `.length` or `.size`.',
+			recommended: 'unopinionated',
+		},
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-incorrect-query-selector.js

@@ -144,16 +144,20 @@ const getQuerySelectorAllCallForLengthCheck = (node, sourceCode) => {
 
 const getLengthCheckProblem = (node, context) => {
 	const {sourceCode} = context;
-	const querySelectorAllCall = getQuerySelectorAllCallForLengthCheck(node, sourceCode);
-	if (!querySelectorAllCall) {
-		return;
-	}
 
+	// Cheap structural checks first, so the expensive scope resolution in
+	// `getQuerySelectorAllCallForLengthCheck` runs only for identifiers that are
+	// actually used as a control-flow test.
 	const {node: booleanAncestor, isNegative} = getBooleanAncestor(node, context);
 	if (!isControlFlowTest(booleanAncestor)) {
 		return;
 	}
 
+	const querySelectorAllCall = getQuerySelectorAllCallForLengthCheck(node, sourceCode);
+	if (!querySelectorAllCall) {
+		return;
+	}
+
 	const text = sourceCode.getText(node);
 
 	return {