eslint-plugin-unicorn 67.0.0 → 69.0.0

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

@@ -0,0 +1,360 @@
+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(['!=', '!==']);
+
+// `{...{}}`, `{...undefined}`, and `{...null}` all spread nothing.
+const isEmptySpreadBranch = node =>
+	isEmptyObjectExpression(node)
+	|| isUndefined(node)
+	|| isNullLiteral(node);
+
+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 = isEmptySpreadBranch(alternate);
+	const isConsequentEmpty = isEmptySpreadBranch(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 !== '&&'
+		|| isEmptySpreadBranch(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}) {

package/rules/consistent-tuple-labels.js

@@ -0,0 +1,49 @@
+const MESSAGE_ID = 'consistent-tuple-labels';
+const messages = {
+	[MESSAGE_ID]: 'This tuple element should have a label, just like the other elements.',
+};
+
+// A rest element keeps its label inside the `TSRestType` wrapper, e.g. `[...rest: number[]]`.
+const isLabeledElement = element =>
+	element.type === 'TSNamedTupleMember'
+	|| (element.type === 'TSRestType' && element.typeAnnotation.type === 'TSNamedTupleMember');
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('TSTupleType', node => {
+		const elements = node.elementTypes;
+
+		// A tuple with fewer than two elements can't be inconsistent.
+		if (elements.length < 2) {
+			return;
+		}
+
+		const unlabeledElements = elements.filter(element => !isLabeledElement(element));
+
+		// All labeled or all unlabeled is consistent.
+		if (unlabeledElements.length === 0 || unlabeledElements.length === elements.length) {
+			return;
+		}
+
+		// At least one element is labeled, so flag every unlabeled element.
+		return unlabeledElements.map(element => ({node: element, messageId: MESSAGE_ID}));
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent labels on tuple type elements.',
+			recommended: true,
+		},
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/custom-error-definition.js

@@ -1,9 +1,13 @@
+import {getPropertyName} from '@eslint-community/eslint-utils';
 import {
 	upperFirst,
 	getParenthesizedText,
 	isNodeMatchesNameOrPath,
 } from './utils/index.js';
-import {isUndefined} from './ast/index.js';
+import {
+	getStaticStringValue,
+	isUndefined,
+} from './ast/index.js';
 
 const MESSAGE_ID_INVALID_EXPORT = 'invalidExport';
 const MESSAGE_ID_DO_NOT_PASS_MESSAGE_TO_SUPER = 'doNotPassMessageToSuper';
@@ -73,8 +77,7 @@ const isPropertyDefinition = (node, name) =>
 	&& node.key.name === name;
 
 const isValidNameProperty = (nameProperty, className) =>
-	nameProperty?.value
-	&& nameProperty.value.value === className;
+	getStaticStringValue(nameProperty?.value) === className;
 
 const isMessageAccessor = (node, kind) =>
 	node.type === 'MethodDefinition'
@@ -200,6 +203,20 @@ const isSameIdentifier = (node, identifier) =>
 	node?.type === 'Identifier'
 	&& node.name === identifier.name;
 
+// Whether `super()` already forwards the error options inline, e.g. `super('Fixed message', {cause})`.
+const hasInlineErrorOptions = (superCallExpression, shouldPassMessageToSuper) => {
+	if (shouldPassMessageToSuper) {
+		return false;
+	}
+
+	const [messageArgument, optionsArgument] = superCallExpression.arguments;
+	return superCallExpression.arguments.length === 2
+		&& getStaticStringValue(messageArgument) !== undefined
+		&& optionsArgument.type === 'ObjectExpression'
+		&& optionsArgument.properties.length === 1
+		&& getPropertyName(optionsArgument.properties[0]) === 'cause';
+};
+
 const getErrorOptionsProblem = (context, constructor, superExpression, hasMessageAccessor) => {
 	const parameters = constructor.value.params;
 	const firstParameter = parameters[0];
@@ -236,6 +253,11 @@ const getErrorOptionsProblem = (context, constructor, superExpression, hasMessag
 	const messageArgumentText = shouldPassMessageToSuper ? firstParameterIdentifier.name : 'undefined';
 
 	if (!optionsParameter) {
+		// When `options` is already forwarded to `super()` (e.g. `super('Fixed message', {cause})`), a dedicated `options` parameter isn't needed.
+		if (hasInlineErrorOptions(superCallExpression, shouldPassMessageToSuper)) {
+			return;
+		}
+
 		return {
 			node: firstParameter,
 			messageId: MESSAGE_ID_MISSING_OPTIONS_PARAMETER,
@@ -282,10 +304,7 @@ function getInvalidErrorNameProblem(constructorBodyNode, constructorBody, errorD
 		return;
 	}
 
-	if (
-		nameExpression.expression.right.type !== 'Literal'
-		|| nameExpression.expression.right.value !== name
-	) {
+	if (getStaticStringValue(nameExpression.expression.right) !== name) {
 		return createInvalidNameError(nameExpression.expression.right ?? constructorBodyNode, name);
 	}
 }