eslint-plugin-unicorn 63.0.0 → 65.0.0

package/rules/expiring-todo-comments.js

@@ -256,20 +256,22 @@ function tryToCoerceVersion(rawVersion) {
 	}
 }
 
-function semverComparisonForOperator(operator) {
-	return {
-		'>': semver.gt,
-		'>=': semver.gte,
-	}[operator];
+function satisfiesRange(version, condition, range) {
+	return semver.satisfies(version, `${condition}${range}`, {includePrerelease: true});
 }
 
 const DEFAULT_OPTIONS = {
 	terms: ['todo', 'fixme', 'xxx'],
 	ignore: [],
-	ignoreDatesOnPullRequests: true,
+	checkDates: false,
+	checkDatesOnPullRequests: false,
 	allowWarningComments: true,
 };
 
+function getAllComments(sourceCode) {
+	return sourceCode.getAllComments?.() ?? sourceCode.comments ?? [];
+}
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const options = {
@@ -277,15 +279,13 @@ const create = context => {
 		...context.options[0],
 	};
 
-	const ignoreRegexes = options.ignore.map(
-		pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u'),
-	);
+	const ignoreRegexes = options.ignore.map(pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u'));
 
 	const dirname = path.dirname(context.filename);
 	const {packageJson, packageDependencies, parseArgument, parseTodoMessage, parseTodoWithArguments} = getPackageHelpers(dirname);
 
 	const {sourceCode} = context;
-	const comments = sourceCode.getAllComments();
+	const comments = getAllComments(sourceCode);
 	const unusedComments = comments
 		.filter(comment => comment.type !== 'Shebang' && !isEslintDisableOrEnableDirective(context, comment))
 		// Block comments come as one.
@@ -299,8 +299,7 @@ const create = context => {
 			comment.value.split('\n').map(line => ({
 				...comment,
 				value: line,
-			})),
-		).filter(comment => processComment(comment));
+			}))).filter(comment => processComment(comment));
 
 	// This is highly dependable on ESLint's `no-warning-comments` implementation.
 	// What we do is patch the parts we know the rule will use, `getAllComments`.
@@ -342,63 +341,48 @@ const create = context => {
 			engines = [],
 			unknowns = [],
 		} = parsed;
+		const todoMessage = parseTodoMessage(comment.value);
 
-		if (dates.length > 1) {
-			uses++;
+		function report(messageId, data = {}) {
 			context.report({
-				loc: sourceCode.getLoc(comment),
-				messageId: MESSAGE_ID_AVOID_MULTIPLE_DATES,
+				node: comment,
+				messageId,
 				data: {
-					expirationDates: dates.join(', '),
-					message: parseTodoMessage(comment.value),
+					...data,
+					message: todoMessage,
 				},
 			});
+		}
+
+		if (dates.length > 1) {
+			uses++;
+			report(MESSAGE_ID_AVOID_MULTIPLE_DATES, {
+				expirationDates: dates.join(', '),
+			});
 		} else if (dates.length === 1) {
 			uses++;
 			const [expirationDate] = dates;
 
-			const shouldIgnore = options.ignoreDatesOnPullRequests && ci.isPR;
-			if (!shouldIgnore && reachedDate(expirationDate, options.date)) {
-				context.report({
-					loc: sourceCode.getLoc(comment),
-					messageId: MESSAGE_ID_EXPIRED_TODO,
-					data: {
-						expirationDate,
-						message: parseTodoMessage(comment.value),
-					},
-				});
+			const shouldCheckDate = options.checkDates && (options.checkDatesOnPullRequests || !ci.isPR);
+			if (shouldCheckDate && reachedDate(expirationDate, options.date)) {
+				report(MESSAGE_ID_EXPIRED_TODO, {expirationDate});
 			}
 		}
 
 		if (packageVersions.length > 1) {
 			uses++;
-			context.report({
-				loc: sourceCode.getLoc(comment),
-				messageId: MESSAGE_ID_AVOID_MULTIPLE_PACKAGE_VERSIONS,
-				data: {
-					versions: packageVersions
-						.map(({condition, version}) => `${condition}${version}`)
-						.join(', '),
-					message: parseTodoMessage(comment.value),
-				},
+			report(MESSAGE_ID_AVOID_MULTIPLE_PACKAGE_VERSIONS, {
+				versions: packageVersions
+					.map(({condition, version}) => `${condition}${version}`)
+					.join(', '),
 			});
 		} else if (packageVersions.length === 1) {
 			uses++;
 			const [{condition, version}] = packageVersions;
 
 			const packageVersion = tryToCoerceVersion(packageJson.version);
-			const decidedPackageVersion = tryToCoerceVersion(version);
-
-			const compare = semverComparisonForOperator(condition);
-			if (packageVersion && compare(packageVersion, decidedPackageVersion)) {
-				context.report({
-					loc: sourceCode.getLoc(comment),
-					messageId: MESSAGE_ID_REACHED_PACKAGE_VERSION,
-					data: {
-						comparison: `${condition}${version}`,
-						message: parseTodoMessage(comment.value),
-					},
-				});
+			if (packageVersion && satisfiesRange(packageVersion, condition, version)) {
+				report(MESSAGE_ID_REACHED_PACKAGE_VERSION, {comparison: `${condition}${version}`});
 			}
 		}
 
@@ -417,20 +401,12 @@ const create = context => {
 						: [!hasTargetPackage, MESSAGE_ID_DONT_HAVE_PACKAGE];
 
 				if (trigger) {
-					context.report({
-						loc: sourceCode.getLoc(comment),
-						messageId,
-						data: {
-							package: dependency.name,
-							message: parseTodoMessage(comment.value),
-						},
-					});
+					report(messageId, {package: dependency.name});
 				}
 
 				continue;
 			}
 
-			const todoVersion = tryToCoerceVersion(dependency.version);
 			const targetPackageVersion = tryToCoerceVersion(targetPackageRawVersion);
 
 			/* c8 ignore start */
@@ -440,17 +416,8 @@ const create = context => {
 			}
 			/* c8 ignore end */
 
-			const compare = semverComparisonForOperator(dependency.condition);
-
-			if (compare(targetPackageVersion, todoVersion)) {
-				context.report({
-					loc: sourceCode.getLoc(comment),
-					messageId: MESSAGE_ID_VERSION_MATCHES,
-					data: {
-						comparison: `${dependency.name} ${dependency.condition} ${dependency.version}`,
-						message: parseTodoMessage(comment.value),
-					},
-				});
+			if (satisfiesRange(targetPackageVersion, dependency.condition, dependency.version)) {
+				report(MESSAGE_ID_VERSION_MATCHES, {comparison: `${dependency.name} ${dependency.condition} ${dependency.version}`});
 			}
 		}
 
@@ -467,22 +434,10 @@ const create = context => {
 				continue;
 			}
 
-			const todoEngine = tryToCoerceVersion(engine.version);
-			const targetPackageEngineVersion = tryToCoerceVersion(
-				targetPackageRawEngineVersion,
-			);
-
-			const compare = semverComparisonForOperator(engine.condition);
+			const targetPackageEngineVersion = tryToCoerceVersion(targetPackageRawEngineVersion);
 
-			if (compare(targetPackageEngineVersion, todoEngine)) {
-				context.report({
-					loc: sourceCode.getLoc(comment),
-					messageId: MESSAGE_ID_ENGINE_MATCHES,
-					data: {
-						comparison: `node${engine.condition}${engine.version}`,
-						message: parseTodoMessage(comment.value),
-					},
-				});
+			if (targetPackageEngineVersion && satisfiesRange(targetPackageEngineVersion, engine.condition, engine.version)) {
+				report(MESSAGE_ID_ENGINE_MATCHES, {comparison: `node${engine.condition}${engine.version}`});
 			}
 		}
 
@@ -499,14 +454,9 @@ const create = context => {
 
 				if (parseArgument(testString).type !== 'unknowns') {
 					uses++;
-					context.report({
-						loc: sourceCode.getLoc(comment),
-						messageId: MESSAGE_ID_MISSING_AT_SYMBOL,
-						data: {
-							original: unknown,
-							fix: testString,
-							message: parseTodoMessage(comment.value),
-						},
+					report(MESSAGE_ID_MISSING_AT_SYMBOL, {
+						original: unknown,
+						fix: testString,
 					});
 					continue;
 				}
@@ -516,14 +466,9 @@ const create = context => {
 
 			if (parseArgument(withoutWhitespace).type !== 'unknowns') {
 				uses++;
-				context.report({
-					loc: sourceCode.getLoc(comment),
-					messageId: MESSAGE_ID_REMOVE_WHITESPACE,
-					data: {
-						original: unknown,
-						fix: withoutWhitespace,
-						message: parseTodoMessage(comment.value),
-					},
+				report(MESSAGE_ID_REMOVE_WHITESPACE, {
+					original: unknown,
+					fix: withoutWhitespace,
 				});
 				continue;
 			}
@@ -532,7 +477,7 @@ const create = context => {
 		return uses === 0;
 	}
 
-	context.on('Program', () => {
+	context.on(['Program', 'StyleSheet'], () => {
 		rules.Program(); // eslint-disable-line new-cap
 	});
 };
@@ -547,20 +492,29 @@ const schema = [
 				items: {
 					type: 'string',
 				},
+				description: 'Comment terms to check.',
 			},
 			ignore: {
 				type: 'array',
 				uniqueItems: true,
+				description: 'Patterns to ignore.',
+			},
+			checkDates: {
+				type: 'boolean',
+				description: 'Whether to check expiration dates.',
 			},
-			ignoreDatesOnPullRequests: {
+			checkDatesOnPullRequests: {
 				type: 'boolean',
+				description: 'Whether to check expiration dates on pull requests.',
 			},
 			allowWarningComments: {
 				type: 'boolean',
+				description: 'Whether to allow warning comments.',
 			},
 			date: {
 				type: 'string',
 				format: 'date',
+				description: 'The reference date.',
 			},
 		},
 	},

package/rules/explicit-length-check.js

@@ -3,11 +3,13 @@ import {
 	isParenthesized,
 	checkVueTemplate,
 	isLogicalExpression,
-	isBooleanNode,
+	isBooleanExpression,
+	isControlFlowTest,
 	getBooleanAncestor,
+	isSameReference,
 } from './utils/index.js';
 import {fixSpaceAroundKeyword} from './fix/index.js';
-import {isLiteral, isMemberExpression, isNumericLiteral} from './ast/index.js';
+import {isLiteral, isMemberExpression} from './ast/index.js';
 
 const TYPE_NON_ZERO = 'non-zero';
 const TYPE_ZERO = 'zero';
@@ -47,8 +49,107 @@ const zeroStyle = {
 	test: node => isCompareRight(node, '===', 0),
 };
 
-function getLengthCheckNode(node) {
+const shapeProperties = new Set(['depth', 'height', 'width']);
+
+function isLengthOrSizeMemberExpression(node) {
+	return isMemberExpression(node, {
+		properties: ['length', 'size'],
+		optional: false,
+	});
+}
+
+function isTypeScriptExpression(node) {
+	return node?.type === 'TSAsExpression'
+		|| node?.type === 'TSSatisfiesExpression'
+		|| node?.type === 'TSTypeAssertion'
+		|| node?.type === 'TSNonNullExpression';
+}
+
+function unwrapTypeScriptExpression(node) {
+	if (isTypeScriptExpression(node)) {
+		return unwrapTypeScriptExpression(node.expression);
+	}
+
+	return node;
+}
+
+function getLengthCheckParent(node, allowTypeScriptExpression) {
 	node = node.parent;
+	if (allowTypeScriptExpression) {
+		while (isTypeScriptExpression(node)) {
+			node = node.parent;
+		}
+	}
+
+	return node;
+}
+
+function getLogicalExpressionRoot(node) {
+	while (
+		isLogicalExpression(node.parent)
+		&& node.parent.operator === '&&'
+	) {
+		node = node.parent;
+	}
+
+	return node;
+}
+
+function getLogicalExpressionOperands(node) {
+	return [node.left, node.right].flatMap(child =>
+		child.type === 'LogicalExpression' && child.operator === node.operator
+			? getLogicalExpressionOperands(child)
+			: [child]);
+}
+
+function hasSameObjectShapePropertyCheck({node, lengthNode}) {
+	const root = getLogicalExpressionRoot(node);
+	if (
+		root.type !== 'LogicalExpression'
+		|| root.operator !== '&&'
+	) {
+		return false;
+	}
+
+	return getLogicalExpressionOperands(root).some(operand =>
+		operand !== node
+		&& isMemberExpression(operand, {computed: false, optional: false})
+		&& operand.property.type === 'Identifier'
+		&& shapeProperties.has(operand.property.name)
+		&& isSameReference(operand.object, lengthNode.object));
+}
+
+function getLengthCheckMemberExpression(node) {
+	if (node.type === 'UnaryExpression' && node.operator === '!') {
+		return getLengthCheckMemberExpression(node.argument);
+	}
+
+	if (
+		node.type === 'CallExpression'
+		&& node.callee.type === 'Identifier'
+		&& node.callee.name === 'Boolean'
+		&& node.arguments.length === 1
+	) {
+		return getLengthCheckMemberExpression(node.arguments[0]);
+	}
+
+	if (node.type !== 'BinaryExpression') {
+		return;
+	}
+
+	const left = unwrapTypeScriptExpression(node.left);
+	if (isLengthOrSizeMemberExpression(left)) {
+		return left;
+	}
+
+	const right = unwrapTypeScriptExpression(node.right);
+	if (isLengthOrSizeMemberExpression(right)) {
+		return right;
+	}
+}
+
+function getLengthCheckNode(node, {allowTypeScriptExpression = false} = {}) {
+	node = getLengthCheckParent(node, allowTypeScriptExpression);
 
 	// Zero length check
 	if (
@@ -80,7 +181,7 @@ function getLengthCheckNode(node) {
 		|| isCompareRight(node, '>=', 1)
 		// `0 !== foo.length`
 		|| isCompareLeft(node, '!==', 0)
-		// `0 !== foo.length`
+		// `0 != foo.length`
 		|| isCompareLeft(node, '!=', 0)
 		// `0 < foo.length`
 		|| isCompareLeft(node, '<', 0)
@@ -93,26 +194,33 @@ function getLengthCheckNode(node) {
 	return {};
 }
 
-function isNodeValueNumber(node, context) {
-	if (isNumericLiteral(node)) {
-		return true;
+function isSameLengthNonZeroCheck(node, lengthNode) {
+	const comparisonLengthNode = getLengthCheckMemberExpression(node);
+	if (!comparisonLengthNode || !isSameReference(comparisonLengthNode, lengthNode)) {
+		return false;
 	}
 
-	const staticValue = getStaticValue(node, context.sourceCode.getScope(node));
-	return staticValue && typeof staticValue.value === 'number';
-}
-
-function isNodeValueString(node, context) {
-	if (node.type === 'Literal' && typeof node.value === 'string') {
-		return true;
+	const {isZeroLengthCheck, node: lengthCheckNode} = getLengthCheckNode(comparisonLengthNode, {allowTypeScriptExpression: true});
+	if (!lengthCheckNode) {
+		return false;
 	}
 
-	if (node.type === 'TemplateLiteral') {
-		return true;
+	const {isNegative, node: ancestor} = getBooleanAncestor(lengthCheckNode);
+	return ancestor === node && isNegative === isZeroLengthCheck;
+}
+
+function isLengthGuardedByNonZeroCheck(lengthNode) {
+	const root = getLogicalExpressionRoot(lengthNode);
+	if (
+		root.type !== 'LogicalExpression'
+		|| root.operator !== '&&'
+	) {
+		return false;
 	}
 
-	const staticValue = getStaticValue(node, context.sourceCode.getScope(node));
-	return staticValue && typeof staticValue.value === 'string';
+	return getLogicalExpressionOperands(root).some(operand =>
+		operand !== lengthNode
+		&& isSameLengthNonZeroCheck(operand, lengthNode));
 }
 
 function create(context) {
@@ -120,7 +228,7 @@ function create(context) {
 	const nonZeroStyle = nonZeroStyles.get(options['non-zero']);
 	const {sourceCode} = context;
 
-	function getProblem({node, isZeroLengthCheck, lengthNode, autoFix}) {
+	function getProblem({node, isZeroLengthCheck, lengthNode, autoFix, shouldSuggest = true}) {
 		const {code, test} = isZeroLengthCheck ? zeroStyle : nonZeroStyle;
 		if (test(node)) {
 			return;
@@ -148,7 +256,7 @@ function create(context) {
 
 		if (autoFix) {
 			problem.fix = fix;
-		} else {
+		} else if (shouldSuggest) {
 			problem.suggest = [
 				{
 					messageId: MESSAGE_ID_SUGGESTION,
@@ -162,10 +270,7 @@ function create(context) {
 
 	context.on('MemberExpression', memberExpression => {
 		if (
-			!isMemberExpression(memberExpression, {
-				properties: ['length', 'size'],
-				optional: false,
-			})
+			!isLengthOrSizeMemberExpression(memberExpression)
 			|| memberExpression.object.type === 'ThisExpression'
 		) {
 			return;
@@ -189,16 +294,10 @@ function create(context) {
 			}
 		} else {
 			const {isNegative, node: ancestor} = getBooleanAncestor(lengthNode);
-			if (isBooleanNode(ancestor)) {
+			if (isBooleanExpression(ancestor) || isControlFlowTest(ancestor)) {
 				isZeroLengthCheck = isNegative;
 				node = ancestor;
-			} else if (
-				isLogicalExpression(lengthNode.parent)
-				&& !(
-					lengthNode.parent.operator === '||'
-					&& (isNodeValueNumber(lengthNode.parent.right, context) || isNodeValueString(lengthNode.parent.right, context))
-				)
-			) {
+			} else if (isLogicalExpression(lengthNode.parent) && lengthNode.parent.operator === '&&') {
 				isZeroLengthCheck = isNegative;
 				node = lengthNode;
 				autoFix = false;
@@ -206,11 +305,24 @@ function create(context) {
 		}
 
 		if (node) {
+			if (
+				(node === lengthNode && isLengthGuardedByNonZeroCheck(lengthNode))
+				|| hasSameObjectShapePropertyCheck({node, lengthNode})
+			) {
+				return;
+			}
+
+			const isUnsafeNegationInBinaryExpression = node.type === 'UnaryExpression'
+				&& node.operator === '!'
+				&& node.parent.type === 'BinaryExpression'
+				&& node.parent.left === node;
+
 			return getProblem({
 				node,
 				isZeroLengthCheck,
 				lengthNode,
-				autoFix,
+				autoFix: autoFix && !isUnsafeNegationInBinaryExpression,
+				shouldSuggest: !isUnsafeNegationInBinaryExpression,
 			});
 		}
 	});