eslint-plugin-unicorn 67.0.0 → 68.0.0

package/rules/consistent-boolean-name.js

@@ -198,6 +198,16 @@ const isBooleanVariable = (variable, context) => {
 		return false;
 	}
 
+	// Destructuring patterns (`const {completed} = task`, `const [enabled] = list`) are intentionally not checked, since renaming a destructured binding is more involved than renaming a plain identifier.
+	if (definition.type === 'Variable' && definition.node.id.type !== 'Identifier') {
+		return false;
+	}
+
+	// A setter parameter's name is positional and dictated by the accessor, not chosen freely.
+	if (definition.type === 'Parameter' && definition.node.parent?.kind === 'set') {
+		return false;
+	}
+
 	const scope = sourceCode.getScope(name);
 
 	if (name.typeAnnotation) {
@@ -384,9 +394,11 @@ const create = context => {
 	}
 
 	const checkVariable = variable => {
+		// `hasBooleanPrefix` is a cheap string check, so run it before the expensive
+		// `isBooleanVariable` analysis.
 		if (
-			!isBooleanVariable(variable, context)
-			|| hasBooleanPrefix(variable.name, prefixes)
+			hasBooleanPrefix(variable.name, prefixes)
+			|| !isBooleanVariable(variable, context)
 		) {
 			return;
 		}
@@ -423,8 +435,8 @@ const create = context => {
 
 		if (
 			!name
-			|| !isBooleanProperty(node, context)
 			|| hasBooleanPrefix(name, prefixes)
+			|| !isBooleanProperty(node, context)
 		) {
 			return;
 		}

package/rules/consistent-compound-words.js

@@ -218,6 +218,13 @@ const create = context => {
 			return;
 		}
 
+		// The combined-regex gate is cheap and rejects most names, so run it before the
+		// import/shorthand checks.
+		const replacement = getNameReplacement(variable.name, options);
+		if (!replacement) {
+			return;
+		}
+
 		const [definition] = variable.defs;
 
 		if (!shouldCheckDefaultOrNamespaceImportName(definition, options)) {
@@ -235,11 +242,6 @@ const create = context => {
 			return;
 		}
 
-		const replacement = getNameReplacement(variable.name, options);
-		if (!replacement) {
-			return;
-		}
-
 		const scopes = [
 			...variable.references.map(reference => reference.from),
 			variable.scope,

package/rules/consistent-conditional-object-spread.js

@@ -0,0 +1,354 @@
+import {
+	isEmptyObjectExpression,
+	isNullLiteral,
+	isUndefined,
+} from './ast/index.js';
+import {
+	getParenthesizedText,
+	isParenthesized,
+	isSameReference,
+	shouldAddParenthesesToConditionalExpressionChild,
+	shouldAddParenthesesToLogicalExpressionChild,
+	shouldAddParenthesesToUnaryExpressionArgument,
+} from './utils/index.js';
+
+const STYLE_LOGICAL = 'logical';
+const STYLE_TERNARY = 'ternary';
+
+const MESSAGE_ID = 'consistent-conditional-object-spread';
+const messages = {
+	[MESSAGE_ID]: 'Prefer {{expectedStyle}} conditional object spreads.',
+};
+const nullishOperators = new Set(['==', '===']);
+const nonNullishOperators = new Set(['!=', '!==']);
+
+const isObjectSpreadArgument = node => (
+	node.parent.type === 'SpreadElement'
+	&& node.parent.argument === node
+	&& node.parent.parent.type === 'ObjectExpression'
+	&& node.parent.parent.properties.includes(node.parent)
+);
+
+function isSameNode(left, right, sourceCode) {
+	if (isSameReference(left, right)) {
+		return true;
+	}
+
+	if (left.type !== right.type) {
+		return false;
+	}
+
+	switch (left.type) {
+		case 'AwaitExpression': {
+			return isSameNode(left.argument, right.argument, sourceCode);
+		}
+
+		case 'LogicalExpression': {
+			return (
+				left.operator === right.operator
+				&& isSameNode(left.left, right.left, sourceCode)
+				&& isSameNode(left.right, right.right, sourceCode)
+			);
+		}
+
+		case 'UnaryExpression': {
+			return (
+				left.operator === right.operator
+				&& left.prefix === right.prefix
+				&& isSameNode(left.argument, right.argument, sourceCode)
+			);
+		}
+
+		case 'UpdateExpression': {
+			return false;
+		}
+
+		// No default
+	}
+
+	return sourceCode.getText(left) === sourceCode.getText(right);
+}
+
+function getNullishKind(node) {
+	if (isNullLiteral(node)) {
+		return 'null';
+	}
+
+	if (isUndefined(node)) {
+		return 'undefined';
+	}
+}
+
+function getNullishBinaryCheck(node) {
+	if (
+		node.type !== 'BinaryExpression'
+		|| (!nullishOperators.has(node.operator) && !nonNullishOperators.has(node.operator))
+	) {
+		return;
+	}
+
+	const leftKind = getNullishKind(node.left);
+	const rightKind = getNullishKind(node.right);
+
+	if (Boolean(leftKind) === Boolean(rightKind)) {
+		return;
+	}
+
+	return {
+		reference: leftKind ? node.right : node.left,
+		kind: node.operator.length === 2 ? 'nullish' : (leftKind ?? rightKind),
+		isTrueWhenNullish: nullishOperators.has(node.operator),
+	};
+}
+
+const checksNullAndUndefined = (left, right) =>
+	(left.kind === 'null' && right.kind === 'undefined')
+	|| (left.kind === 'undefined' && right.kind === 'null');
+
+function getNullishTest(node, sourceCode) {
+	const binaryCheck = getNullishBinaryCheck(node);
+
+	if (binaryCheck?.kind === 'nullish') {
+		return binaryCheck;
+	}
+
+	if (node.type !== 'LogicalExpression') {
+		return;
+	}
+
+	const left = getNullishBinaryCheck(node.left);
+	const right = getNullishBinaryCheck(node.right);
+
+	if (
+		!left
+		|| !right
+		|| !isSameNode(left.reference, right.reference, sourceCode)
+	) {
+		return;
+	}
+
+	if (
+		node.operator === '||'
+		&& left.isTrueWhenNullish
+		&& right.isTrueWhenNullish
+		&& checksNullAndUndefined(left, right)
+	) {
+		return {
+			reference: left.reference,
+			isTrueWhenNullish: true,
+		};
+	}
+
+	if (
+		node.operator === '&&'
+		&& !left.isTrueWhenNullish
+		&& !right.isTrueWhenNullish
+		&& checksNullAndUndefined(left, right)
+	) {
+		return {
+			reference: left.reference,
+			isTrueWhenNullish: false,
+		};
+	}
+}
+
+// Render `node` as an operand of a `&&` expression, adding parentheses when precedence requires it.
+function getLogicalOperandText(node, property, context) {
+	let text = getParenthesizedText(node, context);
+
+	if (
+		!isParenthesized(node, context)
+		&& shouldAddParenthesesToLogicalExpressionChild(node, {operator: '&&', property})
+	) {
+		text = `(${text})`;
+	}
+
+	return text;
+}
+
+// Render `!test` as the left operand of a `&&` expression, stripping a leading `!` when present.
+function getNegatedTestText(test, context) {
+	if (
+		test.type === 'UnaryExpression'
+		&& test.operator === '!'
+		&& test.prefix
+	) {
+		return getLogicalOperandText(test.argument, 'left', context);
+	}
+
+	let text = getParenthesizedText(test, context);
+
+	if (
+		!isParenthesized(test, context)
+		&& shouldAddParenthesesToUnaryExpressionArgument(test, '!')
+	) {
+		text = `(${text})`;
+	}
+
+	return `!${text}`;
+}
+
+function getConditionalExpressionChildText(node, context) {
+	let text = getParenthesizedText(node, context);
+
+	if (
+		!isParenthesized(node, context)
+		&& shouldAddParenthesesToConditionalExpressionChild(node)
+	) {
+		text = `(${text})`;
+	}
+
+	return text;
+}
+
+function getConditionalExpressionProblem(conditionalExpression, context) {
+	const {test, consequent, alternate} = conditionalExpression;
+	const isAlternateEmpty = isEmptyObjectExpression(alternate);
+	const isConsequentEmpty = isEmptyObjectExpression(consequent);
+
+	if (isAlternateEmpty === isConsequentEmpty) {
+		return;
+	}
+
+	const keptBranch = isAlternateEmpty ? consequent : alternate;
+	const nullishTest = getNullishTest(test, context.sourceCode);
+	const hasCommentsInside = context.sourceCode.getCommentsInside(conditionalExpression).length > 0;
+
+	if (
+		(
+			isAlternateEmpty
+				? isSameNode(test, keptBranch, context.sourceCode)
+				: (
+					test.type === 'UnaryExpression'
+					&& test.operator === '!'
+					&& test.prefix
+					&& isSameNode(test.argument, keptBranch, context.sourceCode)
+				)
+		)
+		|| (
+			nullishTest
+			&& !hasCommentsInside
+			&& (nullishTest.isTrueWhenNullish ? !isAlternateEmpty : isAlternateEmpty)
+			&& isSameNode(nullishTest.reference, keptBranch, context.sourceCode)
+		)
+	) {
+		return;
+	}
+
+	const testText = isAlternateEmpty
+		? getLogicalOperandText(test, 'left', context)
+		: getNegatedTestText(test, context);
+	const keptBranchText = getLogicalOperandText(keptBranch, 'right', context);
+
+	return {
+		node: conditionalExpression,
+		messageId: MESSAGE_ID,
+		data: {
+			expectedStyle: 'logical',
+		},
+		/** @param {import('eslint').Rule.RuleFixer} fixer */
+		* fix(fixer, {abort}) {
+			if (hasCommentsInside) {
+				return abort();
+			}
+
+			yield fixer.replaceText(conditionalExpression, `${testText} && ${keptBranchText}`);
+		},
+	};
+}
+
+function getLogicalExpressionProblem(logicalExpression, context) {
+	if (
+		logicalExpression.operator !== '&&'
+		|| isEmptyObjectExpression(logicalExpression.right)
+	) {
+		return;
+	}
+
+	if (isSameNode(logicalExpression.left, logicalExpression.right, context.sourceCode)) {
+		return;
+	}
+
+	const nullishTest = getNullishTest(logicalExpression.left, context.sourceCode);
+
+	if (
+		nullishTest
+		&& !nullishTest.isTrueWhenNullish
+		&& isSameNode(nullishTest.reference, logicalExpression.right, context.sourceCode)
+	) {
+		return;
+	}
+
+	const testText = getConditionalExpressionChildText(logicalExpression.left, context);
+	const consequentText = getConditionalExpressionChildText(logicalExpression.right, context);
+
+	return {
+		node: logicalExpression,
+		messageId: MESSAGE_ID,
+		data: {
+			expectedStyle: 'ternary',
+		},
+		/** @param {import('eslint').Rule.RuleFixer} fixer */
+		* fix(fixer, {abort}) {
+			if (context.sourceCode.getCommentsInside(logicalExpression).length > 0) {
+				return abort();
+			}
+
+			yield fixer.replaceText(logicalExpression, `${testText} ? ${consequentText} : {}`);
+		},
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const style = context.options[0];
+
+	if (style === STYLE_TERNARY) {
+		context.on('LogicalExpression', logicalExpression => {
+			if (!isObjectSpreadArgument(logicalExpression)) {
+				return;
+			}
+
+			return getLogicalExpressionProblem(logicalExpression, context);
+		});
+
+		return;
+	}
+
+	context.on('ConditionalExpression', conditionalExpression => {
+		if (!isObjectSpreadArgument(conditionalExpression)) {
+			return;
+		}
+
+		return getConditionalExpressionProblem(conditionalExpression, context);
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent conditional object spread style.',
+			recommended: true,
+		},
+		fixable: 'code',
+		schema: [
+			{
+				description: 'The conditional object spread style to enforce.',
+				enum: [
+					STYLE_LOGICAL,
+					STYLE_TERNARY,
+				],
+			},
+		],
+		defaultOptions: [STYLE_LOGICAL],
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/consistent-destructuring.js

@@ -66,6 +66,11 @@ const shouldIgnoreMemberExpression = node =>
 		isCallOrNewExpression(node.parent)
 		&& node.parent.callee === node
 	)
+	// Replacing the tag would change the `this` binding, like a method call.
+	|| (
+		node.parent.type === 'TaggedTemplateExpression'
+		&& node.parent.tag === node
+	)
 	|| isLeftHandSide(node);
 
 const isRootVariableReassigned = (declaration, memberExpressionNode, memberScope, sourceCode) => {

package/rules/consistent-existence-index-check.js

@@ -84,7 +84,7 @@ const create = context => {
 			const replacement = getReplacement(binaryExpression);
 
 			if (!replacement) {
-				return;
+				continue;
 			}
 
 			const {left, operator, right} = binaryExpression;

package/rules/consistent-json-file-read.js

@@ -92,14 +92,8 @@ function isUtf8Encoding(node, scope) {
 	}
 
 	const {value} = staticValue;
-	if (
-		isSingleEncodingOptionObject(value)
-		&& isUtf8EncodingString(value.encoding)
-	) {
-		return true;
-	}
-
-	return false;
+	return Boolean(isSingleEncodingOptionObject(value)
+		&& isUtf8EncodingString(value.encoding));
 }
 
 function isBufferEncoding(node, scope) {
@@ -113,14 +107,8 @@ function isBufferEncoding(node, scope) {
 		return true;
 	}
 
-	if (
-		isSingleEncodingOptionObject(value)
-		&& (value.encoding === undefined || value.encoding === null)
-	) {
-		return true;
-	}
-
-	return false;
+	return Boolean(isSingleEncodingOptionObject(value)
+		&& (value.encoding === undefined || value.encoding === null));
 }
 
 function isJsonReadFileCall(node, scope) {

package/rules/consistent-optional-chaining.js

@@ -1,5 +1,6 @@
 import {
-	getParenthesizedRange,
+	getMemberAccessOperatorRange,
+	hasCommentInRange,
 	isSameReference,
 	unwrapTypeScriptExpression,
 } from './utils/index.js';
@@ -60,28 +61,10 @@ function isSupportedMemberBase(node) {
 	return false;
 }
 
-function getMemberAccessOperatorRange(memberExpression, context) {
-	const {sourceCode} = context;
-	const [, start] = getParenthesizedRange(memberExpression.object, context);
-	const end = memberExpression.computed
-		? sourceCode.getRange(sourceCode.getTokenBefore(memberExpression.property, token => token.value === '['))[1]
-		: sourceCode.getRange(memberExpression.property)[0];
-
-	return [start, end];
-}
-
-function hasCommentInRange(sourceCode, [start, end]) {
-	return sourceCode.getAllComments().some(comment => {
-		const [commentStart, commentEnd] = sourceCode.getRange(comment);
-
-		return commentStart >= start && commentEnd <= end;
-	});
-}
-
 function canReplaceMemberAccessOperator(memberExpression, context) {
 	const range = getMemberAccessOperatorRange(memberExpression, context);
 
-	return !hasCommentInRange(context.sourceCode, range);
+	return !hasCommentInRange(context, range);
 }
 
 function replaceMemberAccessOperator({memberExpression, context, fixer, replacement}) {