eslint-plugin-unicorn 63.0.0 → 65.0.0

package/rules/utils/boolean.js

@@ -15,48 +15,57 @@ const isVueBooleanAttributeValue = node =>
 	&& node.parent.value === node
 	&& node.parent.key.type === 'VDirectiveKey'
 	&& node.parent.key.name.type === 'VIdentifier'
-	&& (
-		node.parent.key.name.rawName === 'if'
-		|| node.parent.key.name.rawName === 'else-if'
-		|| node.parent.key.name.rawName === 'show'
-	);
+	&& [
+		'if',
+		'else-if',
+		'show',
+	].includes(node.parent.key.name.rawName);
+const isDirectControlFlowTest = node =>
+	[
+		'IfStatement',
+		'ConditionalExpression',
+		'WhileStatement',
+		'DoWhileStatement',
+		'ForStatement',
+	].includes(node.parent.type)
+	&& node.parent.test === node;
+const isDirectBooleanExpression = node =>
+	isLogicNot(node)
+	|| isLogicNotArgument(node)
+	|| isBooleanCall(node)
+	|| isBooleanCallArgument(node);
 
 /**
-Check if the value of node is a `boolean`.
+Check if the expression value of `node` is a `boolean`.
 
 @param {Node} node
 @returns {boolean}
 */
-export function isBooleanNode(node) {
-	if (
-		isLogicNot(node)
-		|| isLogicNotArgument(node)
-		|| isBooleanCall(node)
-		|| isBooleanCallArgument(node)
-	) {
+export function isBooleanExpression(node) {
+	if (isDirectBooleanExpression(node)) {
 		return true;
 	}
 
-	const {parent} = node;
-	if (isVueBooleanAttributeValue(parent)) {
-		return true;
+	if (isLogicalExpression(node.parent)) {
+		return isBooleanExpression(node.parent);
 	}
 
-	if (
-		(
-			parent.type === 'IfStatement'
-			|| parent.type === 'ConditionalExpression'
-			|| parent.type === 'WhileStatement'
-			|| parent.type === 'DoWhileStatement'
-			|| parent.type === 'ForStatement'
-		)
-		&& parent.test === node
-	) {
+	return false;
+}
+
+/**
+Check if `node` is used as a control-flow test.
+
+@param {Node} node
+@returns {boolean}
+*/
+export function isControlFlowTest(node) {
+	if (isVueBooleanAttributeValue(node.parent) || isDirectControlFlowTest(node)) {
 		return true;
 	}
 
-	if (isLogicalExpression(parent)) {
-		return isBooleanNode(parent);
+	if (isLogicalExpression(node.parent)) {
+		return isControlFlowTest(node.parent);
 	}
 
 	return false;

package/rules/utils/create-deprecated-rules.js

@@ -1,36 +1,34 @@
-import getDocumentationUrl from './get-documentation-url.js';
 import packageJson from '../../package.json' with {type: 'json'};
+import getDocumentationUrl from './get-documentation-url.js';
 
 const repoUrl = 'https://github.com/sindresorhus/eslint-plugin-unicorn';
 
 /** @returns {{ [ruleName: string]: import('eslint').Rule.RuleModule }} */
 export default function createDeprecatedRules(rules) {
-	return Object.fromEntries(
-		Object.entries(rules).map(([ruleId, deprecatedInfo]) => {
-			const url = `${repoUrl}/blob/v${packageJson.version}/docs/deleted-and-deprecated-rules.md#${ruleId}`;
-			return [
-				ruleId,
-				{
-					// eslint-disable-next-line internal/prefer-context-on
-					create: () => ({}),
-					meta: {
-						docs: {
-							description: deprecatedInfo.message,
-							url,
-						},
-						deprecated: {
-							message: deprecatedInfo.message,
-							url,
-							replacedBy: deprecatedInfo.replacedBy.map(replacementRuleId => ({
-								rule: {
-									name: replacementRuleId,
-									url: getDocumentationUrl(replacementRuleId),
-								},
-							})),
-						},
+	return Object.fromEntries(Object.entries(rules).map(([ruleId, deprecatedInfo]) => {
+		const url = `${repoUrl}/blob/v${packageJson.version}/docs/deleted-and-deprecated-rules.md#${ruleId}`;
+		return [
+			ruleId,
+			{
+				// eslint-disable-next-line internal/prefer-context-on
+				create: () => ({}),
+				meta: {
+					docs: {
+						description: deprecatedInfo.message,
+						url,
+					},
+					deprecated: {
+						message: deprecatedInfo.message,
+						url,
+						replacedBy: deprecatedInfo.replacedBy.map(replacementRuleId => ({
+							rule: {
+								name: replacementRuleId,
+								url: getDocumentationUrl(replacementRuleId),
+							},
+						})),
 					},
 				},
-			];
-		}),
-	);
+			},
+		];
+	}));
 }

package/rules/utils/get-call-expression-arguments-text.js

@@ -26,11 +26,9 @@ export default function getCallExpressionArgumentsText(
 	} = getCallExpressionTokens(callExpression, context);
 
 	const [, start] = sourceCode.getRange(openingParenthesisToken);
-	const [end] = sourceCode.getRange(
-		includeTrailingComma
-			? closingParenthesisToken
-			: (trailingCommaToken ?? closingParenthesisToken),
-	);
+	const [end] = sourceCode.getRange(includeTrailingComma
+		? closingParenthesisToken
+		: (trailingCommaToken ?? closingParenthesisToken));
 
 	return sourceCode.text.slice(start, end);
 }

package/rules/utils/get-duplicate-array-elements.js

@@ -0,0 +1,77 @@
+import {getStaticValue} from '@eslint-community/eslint-utils';
+import isSameReference from './is-same-reference.js';
+
+export const isComparableStaticValue = value =>
+	value === null
+	|| (
+		typeof value !== 'object'
+		&& typeof value !== 'function'
+	);
+
+const isSameValueZero = (left, right) =>
+	left === right
+	|| (
+		typeof left === 'number'
+		&& typeof right === 'number'
+		&& Number.isNaN(left)
+		&& Number.isNaN(right)
+	);
+
+const getComparableStaticElementValueResult = (element, context) => {
+	if (!element) {
+		return {value: undefined};
+	}
+
+	const {sourceCode} = context;
+	const result = getStaticValue(element, sourceCode.getScope(element));
+
+	if (!result || !isComparableStaticValue(result.value)) {
+		return;
+	}
+
+	return {value: result.value};
+};
+
+const isDuplicateValue = (leftElement, rightElement, context) => {
+	const leftStaticValueResult = getComparableStaticElementValueResult(leftElement, context);
+	const rightStaticValueResult = getComparableStaticElementValueResult(rightElement, context);
+
+	if (
+		leftStaticValueResult
+		&& rightStaticValueResult
+	) {
+		return isSameValueZero(leftStaticValueResult.value, rightStaticValueResult.value);
+	}
+
+	if (
+		!leftElement
+		|| !rightElement
+		|| leftElement.type === 'Literal'
+		|| rightElement.type === 'Literal'
+	) {
+		return false;
+	}
+
+	return isSameReference(leftElement, rightElement);
+};
+
+const getDuplicateArrayElements = (elements, context) => {
+	const checkedElements = [];
+	const duplicateElements = [];
+
+	for (const element of elements) {
+		if (element?.type === 'SpreadElement') {
+			continue;
+		}
+
+		if (checkedElements.some(checkedElement => isDuplicateValue(checkedElement, element, context))) {
+			duplicateElements.push(element);
+		}
+
+		checkedElements.push(element);
+	}
+
+	return duplicateElements;
+};
+
+export default getDuplicateArrayElements;

package/rules/utils/index.js

@@ -16,7 +16,8 @@ export {
 } from './is-node-matches.js';
 
 export {
-	isBooleanNode,
+	isBooleanExpression,
+	isControlFlowTest,
 	getBooleanAncestor,
 } from './boolean.js';
 
@@ -27,6 +28,7 @@ export {default as getClassHeadLocation} from './get-class-head-location.js';
 export {default as getAvailableVariableName} from './get-available-variable-name.js';
 export {default as getCallExpressionArgumentsText} from './get-call-expression-arguments-text.js';
 export {getCallExpressionTokens, getNewExpressionTokens} from './get-call-or-new-expression-tokens.js';
+export {default as getDuplicateArrayElements, isComparableStaticValue} from './get-duplicate-array-elements.js';
 export {default as getIndentString} from './get-indent-string.js';
 export {default as getReferences} from './get-references.js';
 export {default as getScopes} from './get-scopes.js';
@@ -41,6 +43,7 @@ export {default as isNewExpressionWithParentheses} from './is-new-expression-wit
 export {default as isNumber} from './is-number.js';
 export {default as isNodeValueNotDomNode} from './is-node-value-not-dom-node.js';
 export {default as isNodeValueNotFunction} from './is-node-value-not-function.js';
+export {default as isNodeContainsLexicalThis} from './is-node-contains-lexical-this.js';
 export {default as isOnSameLine} from './is-on-same-line.js';
 export {default as isSameIdentifier} from './is-same-identifier.js';
 export {default as isSameReference} from './is-same-reference.js';

package/rules/utils/is-node-contains-lexical-this.js

@@ -0,0 +1,65 @@
+/**
+Check whether a node subtree contains lexical `this`.
+
+This is parser-agnostic and intentionally does not use `scope.thisFound`, because that flag is inconsistent across supported parsers.
+*/
+const isNodeContainsLexicalThis = (node, visitorKeys) => {
+	if (node.type === 'ThisExpression') {
+		return true;
+	}
+
+	if (
+		node.type === 'FunctionDeclaration'
+		|| node.type === 'FunctionExpression'
+	) {
+		// `this` inside non-arrow functions is rebound and does not affect outer arrows.
+		return false;
+	}
+
+	if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+		// Class bodies create their own `this`, but computed keys/superclass are evaluated in outer scope.
+		if (node.superClass && isNodeContainsLexicalThis(node.superClass, visitorKeys)) {
+			return true;
+		}
+
+		for (const classElement of node.body.body) {
+			if (classElement.computed && isNodeContainsLexicalThis(classElement.key, visitorKeys)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	const keys = visitorKeys[node.type];
+
+	if (!keys) {
+		return false;
+	}
+
+	for (const key of keys) {
+		const value = node[key];
+
+		if (!value) {
+			continue;
+		}
+
+		if (Array.isArray(value)) {
+			for (const childNode of value) {
+				if (childNode && isNodeContainsLexicalThis(childNode, visitorKeys)) {
+					return true;
+				}
+			}
+
+			continue;
+		}
+
+		if (isNodeContainsLexicalThis(value, visitorKeys)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+export default isNodeContainsLexicalThis;

package/rules/utils/is-number.js

@@ -200,8 +200,8 @@ export default function isNumber(node, scope) {
 			if (
 				testStaticValueResult !== null
 				&& (
-					(testStaticValueResult.value && isConsequentNumber)
-					|| (!testStaticValueResult.value && isAlternateNumber)
+					(isConsequentNumber && testStaticValueResult.value)
+					|| (isAlternateNumber && !testStaticValueResult.value)
 				)
 			) {
 				return true;

package/rules/utils/is-same-reference.js

@@ -81,12 +81,10 @@ Check if two literal nodes are the same value.
 function equalLiteralValue(left, right) {
 	// RegExp literal.
 	if (left.regex || right.regex) {
-		return Boolean(
-			left.regex
+		return Boolean(left.regex
 			&& right.regex
 			&& left.regex.pattern === right.regex.pattern
-			&& left.regex.flags === right.regex.flags,
-		);
+			&& left.regex.flags === right.regex.flags);
 	}
 
 	// BigInt literal.
@@ -97,6 +95,26 @@ function equalLiteralValue(left, right) {
 	return left.value === right.value;
 }
 
+/**
+Unwrap ChainExpression (`?.`) and TypeScript type assertion (`as`, `<Type>`, or `!`) nodes.
+@param {ASTNode} node The node to unwrap.
+@returns {ASTNode} The unwrapped node.
+*/
+function unwrapNode(node) {
+	if (
+		[
+			'ChainExpression',
+			'TSAsExpression',
+			'TSTypeAssertion',
+			'TSNonNullExpression',
+		].includes(node.type)
+	) {
+		return unwrapNode(node.expression);
+	}
+
+	return node;
+}
+
 /**
 Check if two expressions reference the same value. For example:
 	a = a
@@ -108,16 +126,10 @@ Check if two expressions reference the same value. For example:
 @returns {boolean} `true` if both sides match and reference the same value.
 */
 export default function isSameReference(left, right) {
-	if (left.type !== right.type) {
-		// Handle `a.b` and `a?.b` are samely.
-		if (left.type === 'ChainExpression') {
-			return isSameReference(left.expression, right);
-		}
-
-		if (right.type === 'ChainExpression') {
-			return isSameReference(left, right.expression);
-		}
+	left = unwrapNode(left);
+	right = unwrapNode(right);
 
+	if (left.type !== right.type) {
 		return false;
 	}
 
@@ -136,10 +148,6 @@ export default function isSameReference(left, right) {
 			return equalLiteralValue(left, right);
 		}
 
-		case 'ChainExpression': {
-			return isSameReference(left.expression, right.expression);
-		}
-
 		case 'MemberExpression': {
 			const nameA = getStaticPropertyName(left);
 

package/rules/utils/should-add-parentheses-to-await-expression-argument.js

@@ -5,13 +5,13 @@ Check if parentheses should be added to a `node` when it's used as `argument` of
 @returns {boolean}
 */
 export default function shouldAddParenthesesToAwaitExpressionArgument(node) {
-	return (
-		node.type === 'SequenceExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'ArrowFunctionExpression'
-		|| node.type === 'ConditionalExpression'
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'LogicalExpression'
-		|| node.type === 'BinaryExpression'
-	);
+	return [
+		'SequenceExpression',
+		'YieldExpression',
+		'ArrowFunctionExpression',
+		'ConditionalExpression',
+		'AssignmentExpression',
+		'LogicalExpression',
+		'BinaryExpression',
+	].includes(node.type);
 }

package/rules/utils/should-add-parentheses-to-call-expression-callee.js

@@ -5,14 +5,16 @@ Check if parentheses should be added to a `node` when it's used as `callee` of `
 @returns {boolean}
 */
 export default function shouldAddParenthesesToCallExpressionCallee(node) {
-	return node.type === 'SequenceExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'ArrowFunctionExpression'
-		|| node.type === 'ConditionalExpression'
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'LogicalExpression'
-		|| node.type === 'BinaryExpression'
-		|| node.type === 'UnaryExpression'
-		|| node.type === 'UpdateExpression'
-		|| node.type === 'NewExpression';
+	return [
+		'SequenceExpression',
+		'YieldExpression',
+		'ArrowFunctionExpression',
+		'ConditionalExpression',
+		'AssignmentExpression',
+		'LogicalExpression',
+		'BinaryExpression',
+		'UnaryExpression',
+		'UpdateExpression',
+		'NewExpression',
+	].includes(node.type);
 }

package/rules/utils/should-add-parentheses-to-conditional-expression-child.js

@@ -5,9 +5,13 @@ Check if parentheses should be added to a `node` when it's used as child of `Con
 @returns {boolean}
 */
 export default function shouldAddParenthesesToConditionalExpressionChild(node) {
-	return node.type === 'AwaitExpression'
-		// Lower precedence, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'SequenceExpression';
+	// Lower precedence, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
+	return [
+		'AwaitExpression',
+		'AssignmentExpression',
+		'YieldExpression',
+		'SequenceExpression',
+		'TSAsExpression',
+		'TSTypeAssertion',
+	].includes(node.type);
 }

package/rules/utils/should-add-parentheses-to-expression-statement-expression.js

@@ -1,5 +1,5 @@
 /**
-Check if parentheses should to be added to a `node` when it's used as an `expression` of `ExpressionStatement`.
+Check if parentheses should be added to a `node` when it's used as an `expression` of `ExpressionStatement`.
 
 @param {Node} node - The AST node to check.
 @param {SourceCode} sourceCode - The source code object.

package/rules/utils/should-add-parentheses-to-logical-expression-child.js

@@ -20,8 +20,10 @@ export default function shouldAddParenthesesToLogicalExpressionChild(node, {oper
 
 	// Not really needed, but more readable
 	if (
-		node.type === 'AwaitExpression'
-		|| node.type === 'BinaryExpression'
+		[
+			'AwaitExpression',
+			'BinaryExpression',
+		].includes(node.type)
 	) {
 		return true;
 	}
@@ -29,12 +31,14 @@ export default function shouldAddParenthesesToLogicalExpressionChild(node, {oper
 	// Lower precedence than `LogicalExpression`
 	// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
 	if (
-		node.type === 'LogicalExpression'
-		|| node.type === 'ConditionalExpression'
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'ArrowFunctionExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'SequenceExpression'
+		[
+			'LogicalExpression',
+			'ConditionalExpression',
+			'AssignmentExpression',
+			'ArrowFunctionExpression',
+			'YieldExpression',
+			'SequenceExpression',
+		].includes(node.type)
 	) {
 		return true;
 	}

package/rules/utils/should-add-parentheses-to-member-expression-object.js

@@ -6,7 +6,7 @@ import {isDecimalIntegerNode} from './numeric.js';
 */
 
 /**
-Check if parentheses should to be added to a `node` when it's used as an `object` of `MemberExpression`.
+Check if parentheses should be added to a `node` when it's used as an `object` of `MemberExpression`.
 
 @param {ESTree.Node} node - The AST node to check.
 @param {ESLint.Rule.RuleContext} context - The ESLint rule context object.

package/rules/utils/should-add-parentheses-to-unary-expression.js

@@ -11,14 +11,14 @@ export default function shouldAddParenthesesToUnaryExpressionArgument(node, oper
 		throw new Error('Unexpected operator');
 	}
 
-	return (
-		node.type === 'UpdateExpression'
-		|| node.type === 'BinaryExpression'
-		|| node.type === 'LogicalExpression'
-		|| node.type === 'ConditionalExpression'
-		|| node.type === 'AssignmentExpression'
-		|| node.type === 'ArrowFunctionExpression'
-		|| node.type === 'YieldExpression'
-		|| node.type === 'SequenceExpression'
-	);
+	return [
+		'UpdateExpression',
+		'BinaryExpression',
+		'LogicalExpression',
+		'ConditionalExpression',
+		'AssignmentExpression',
+		'ArrowFunctionExpression',
+		'YieldExpression',
+		'SequenceExpression',
+	].includes(node.type);
 }