eslint-plugin-unicorn 67.0.0 → 68.0.0

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 {

package/rules/no-incorrect-template-string-interpolation.js

@@ -14,17 +14,28 @@ const memberExpression = String.raw`${identifier}(?:\.${identifier})*`;
 const missingDollar = new RegExp(String.raw`(?<![$\\])(?<!\{)\{(?<expression>${memberExpression})\}(?!\})`, 'gv');
 const missingOpeningBrace = new RegExp(String.raw`(?<!\\)(?<!\{)\$(?<expression>${memberExpression})\}(?!\})`, 'gv');
 
-const getMissingDollarReplacements = raw => Array.from(raw.matchAll(missingDollar), match => ({
-	index: match.index,
-	incorrect: match[0],
-	correct: `$${match[0]}`,
-}));
+// `{foo}` at the start of an `import`/`export`/`const`/`let`/`var` line is a named specifier or destructuring pattern, not a missing-dollar mistake (common in code-generation templates). Requiring no `=` (or `;`/`{`/`}`) before it keeps object literals like `const x = {foo}` reported.
+const isBindingDeclaration = (raw, index) => {
+	const lineStart = raw.lastIndexOf('\n', index - 1) + 1;
+	return /^\s*(?:import|export|const|let|var)\b[^;={}]*$/.test(raw.slice(lineStart, index));
+};
+
+const getMissingDollarReplacements = raw => raw.matchAll(missingDollar)
+	.filter(match => !isBindingDeclaration(raw, match.index))
+	.map(match => ({
+		index: match.index,
+		incorrect: match[0],
+		correct: `$${match[0]}`,
+	}))
+	.toArray();
 
-const getMissingOpeningBraceReplacements = raw => Array.from(raw.matchAll(missingOpeningBrace), match => ({
-	index: match.index,
-	incorrect: match[0],
-	correct: `\${${match.groups.expression}}`,
-}));
+const getMissingOpeningBraceReplacements = raw => raw.matchAll(missingOpeningBrace)
+	.map(match => ({
+		index: match.index,
+		incorrect: match[0],
+		correct: `\${${match.groups.expression}}`,
+	}))
+	.toArray();
 
 const getReplacements = raw => {
 	const replacements = [
@@ -80,7 +91,7 @@ const config = {
 		type: 'problem',
 		docs: {
 			description: 'Disallow incorrect template literal interpolation syntax.',
-			recommended: 'unopinionated',
+			recommended: true,
 		},
 		hasSuggestions: true,
 		messages,

package/rules/no-instanceof-builtins.js

@@ -2,6 +2,8 @@ import {
 	checkVueTemplate,
 	getParenthesizedRange,
 	getTokenStore,
+	isParenthesized,
+	shouldAddParenthesesToUnaryExpressionArgument,
 } from './utils/index.js';
 import {replaceNodeOrTokenAndSpacesBefore, fixSpaceAroundKeyword} from './fix/index.js';
 import builtinErrors from './shared/builtin-errors.js';
@@ -86,7 +88,18 @@ const replaceWithTypeOfExpression = (node, context) => function * (fixer) {
 	yield fixSpaceAroundKeyword(fixer, node, context);
 
 	const leftRange = getParenthesizedRange(left, {sourceCode: tokenStore});
-	yield fixer.insertTextBeforeRange(leftRange, 'typeof ');
+
+	// Wrap a low-precedence left operand so `typeof` applies to the whole expression,
+	// e.g. `a + b instanceof Function` -> `typeof (a + b) === 'function'`.
+	if (
+		!isParenthesized(left, context)
+		&& shouldAddParenthesesToUnaryExpressionArgument(left, 'typeof')
+	) {
+		yield fixer.insertTextBeforeRange(leftRange, 'typeof (');
+		yield fixer.insertTextAfterRange(leftRange, ')');
+	} else {
+		yield fixer.insertTextBeforeRange(leftRange, 'typeof ');
+	}
 
 	yield fixer.replaceText(instanceofToken, '===');