eslint-plugin-unicorn 68.0.0 → 69.0.0

package/rules/no-useless-boolean-cast.js

@@ -1,11 +1,60 @@
 import {isFunction, isMethodCall} from './ast/index.js';
-import {isGlobalBooleanCall, isSameIdentifier} from './utils/index.js';
+import {
+	hasOptionalChainElement,
+	isGlobalBooleanCall,
+	isNullishType,
+	isSameIdentifier,
+	unwrapTypeScriptExpression,
+} from './utils/index.js';
 
 const MESSAGE_ID = 'no-useless-boolean-cast';
 const messages = {
 	[MESSAGE_ID]: '`Boolean()` is unnecessary in `Array#{{method}}()` callbacks.',
 };
 
+const isNullishOrVoidType = type =>
+	type.intrinsicName === 'void' || isNullishType(type);
+
+// When type information is available, the `Boolean()` cast is meaningful if the argument's type includes `null`/`undefined`/`void`, since removing it would widen the predicate's return type. Returns `false` when type information is unavailable, so it only ever keeps more casts than the syntactic check alone, never fewer.
+function hasNullishOrVoidType(node, context) {
+	const {parserServices} = context.sourceCode;
+	if (!parserServices?.program) {
+		return false;
+	}
+
+	try {
+		const type = parserServices.getTypeAtLocation(node);
+		const types = type.isUnion() ? type.types : [type];
+		return types.some(type => isNullishOrVoidType(type));
+	} catch {
+		return false;
+	}
+}
+
+function isOptionalChainResult(node) {
+	node = unwrapTypeScriptExpression(node);
+
+	if (node?.type === 'ChainExpression') {
+		return hasOptionalChainElement(node);
+	}
+
+	if (node?.type === 'LogicalExpression') {
+		return node.operator === '&&'
+			? isOptionalChainResult(node.left) || isOptionalChainResult(node.right)
+			: isOptionalChainResult(node.right);
+	}
+
+	if (node?.type === 'ConditionalExpression') {
+		return isOptionalChainResult(node.consequent) || isOptionalChainResult(node.alternate);
+	}
+
+	if (node?.type === 'SequenceExpression') {
+		return isOptionalChainResult(node.expressions.at(-1));
+	}
+
+	return false;
+}
+
 const predicateMethods = [
 	'every',
 	'filter',
@@ -79,6 +128,14 @@ const create = context => {
 			return;
 		}
 
+		// `Boolean()` normalizes a possibly-`undefined` value, so it is not useless. Detect this syntactically via optional chaining, and, when type information is available, via the resolved type.
+		if (
+			isOptionalChainResult(argument)
+			|| hasNullishOrVoidType(argument, context)
+		) {
+			return;
+		}
+
 		return {
 			node: booleanCall,
 			messageId: MESSAGE_ID,

package/rules/no-useless-concat.js

@@ -30,6 +30,11 @@ function getStringValue(node) {
 // Legacy octal (`\1`, `\012`) and `\8`/`\9` escapes are valid in sloppy-mode string literals but are syntax errors inside template literals.
 const hasTemplateIncompatibleEscape = raw => /(?<=(?:^|[^\\])(?:\\\\)*)\\(?:[1-9]|0\d)/v.test(raw);
 
+// Whether the string contains a `${…}` placeholder. The regex mirrors ESLint's `no-template-curly-in-string`, which we defer to, so an empty `${}` is intentionally not matched.
+const hasTemplatePlaceholder = string => /\$\{[^}]+\}/u.test(string);
+
+const formsTemplatePlaceholderBoundary = (leftRaw, rightRaw) => leftRaw.endsWith('$') && rightRaw.startsWith('{');
+
 // The raw inner content of a literal as it would appear inside a template literal.
 function toTemplateElementRaw(node, sourceCode) {
 	if (node.type === 'TemplateLiteral') {
@@ -69,9 +74,28 @@ const create = context => {
 
 		const leftValue = getStringValue(left);
 		const rightValue = getStringValue(right);
-		const replacement = leftValue === undefined || rightValue === undefined
-			? `\`${toTemplateElementRaw(left, sourceCode)}${toTemplateElementRaw(right, sourceCode)}\``
-			: escapeString(leftValue + rightValue);
+
+		// Merging into a single string that contains a `${…}` placeholder produces an ambiguous template-like literal that `no-template-curly-in-string` flags. The split is likely intentional, so leave it alone.
+		if (
+			leftValue !== undefined
+			&& rightValue !== undefined
+			&& hasTemplatePlaceholder(leftValue + rightValue)
+		) {
+			return;
+		}
+
+		let replacement;
+		if (leftValue === undefined || rightValue === undefined) {
+			const leftRaw = toTemplateElementRaw(left, sourceCode);
+			const rightRaw = toTemplateElementRaw(right, sourceCode);
+			if (formsTemplatePlaceholderBoundary(leftRaw, rightRaw)) {
+				return;
+			}
+
+			replacement = `\`${leftRaw}${rightRaw}\``;
+		} else {
+			replacement = escapeString(leftValue + rightValue);
+		}
 
 		const operatorToken = sourceCode.getTokenBefore(right, token => token.type === 'Punctuator' && token.value === '+');
 

package/rules/no-useless-else.js

@@ -1,7 +1,6 @@
 import {
 	hasCommentInRange,
 	hasDirectBlockScopedDeclaration,
-	hasMultilineToken,
 	needsSemicolon,
 	trackBranchExits,
 } from './utils/index.js';
@@ -25,6 +24,7 @@ const statementListParentTypes = new Set([
 const asiHazardCharacters = new Set([
 	'[',
 	'(',
+	'<',
 	'/',
 	'`',
 	'+',
@@ -38,6 +38,20 @@ const getLineIndent = (sourceCode, index) => {
 
 const startsWithAsiHazard = token => asiHazardCharacters.has(token.value[0]);
 
+const isJsxChildTextToken = (token, sourceCode) =>
+	token.type === 'JSXText'
+	&& sourceCode.getNodeByRangeIndex(sourceCode.getRange(token)[0]).type === 'JSXText';
+
+// A multiline token's internal whitespace can be meaningful, so it can't be safely reindented.
+// JSX child text is safe because JSX collapses line-leading and line-trailing whitespace at compile time.
+const hasReindentUnsafeMultilineToken = (node, context) => {
+	const {sourceCode} = context;
+	return sourceCode.getTokens(node).some(token =>
+		!isJsxChildTextToken(token, sourceCode)
+		&& sourceCode.getLoc(token).start.line !== sourceCode.getLoc(token).end.line,
+	);
+};
+
 const getBlockBodyText = (blockStatement, ifStatement, sourceCode) => {
 	const openingBrace = sourceCode.getFirstToken(blockStatement);
 	const closingBrace = sourceCode.getLastToken(blockStatement);
@@ -156,7 +170,7 @@ const fix = (ifStatement, context) => fixer => {
 		hasDirectBlockScopedDeclaration(alternate)
 		|| (
 			alternate.type === 'BlockStatement'
-			&& hasMultilineToken(alternate, context)
+			&& hasReindentUnsafeMultilineToken(alternate, context)
 		)
 		|| !isSafeToMoveAlternate(ifStatement, context)
 	) {

package/rules/no-useless-iterator-to-array.js

@@ -15,7 +15,7 @@ const MESSAGE_ID_SUGGESTION_ITERATOR_METHOD = 'iterator-method/suggestion';
 
 const messages = {
 	[MESSAGE_ID_ITERABLE_ACCEPTING]: '`{{description}}` accepts an iterable, `.toArray()` is unnecessary.',
-	[MESSAGE_ID_FOR_OF]: '`for…of` can iterate over an iterable, `.toArray()` is unnecessary.',
+	[MESSAGE_ID_FOR_OF]: '`for…of`/`for await…of` can iterate over an iterable, `.toArray()` is unnecessary.',
 	[MESSAGE_ID_YIELD_STAR]: '`yield*` can delegate to an iterable, `.toArray()` is unnecessary.',
 	[MESSAGE_ID_SPREAD]: 'Spread works on iterables, `.toArray()` is unnecessary.',
 	[MESSAGE_ID_ITERATOR_METHOD]: '`Iterator` has a `.{{method}}()` method, `.toArray()` is unnecessary.',
@@ -45,6 +45,154 @@ const isToArrayCall = node => isMethodCall(node, {
 	optionalMember: false,
 });
 
+const getRemoveToArrayFix = (toArrayCall, context) => {
+	if (context.sourceCode.getCommentsInside(toArrayCall).length > 0) {
+		return;
+	}
+
+	return fixer => removeMethodCall(fixer, toArrayCall, context);
+};
+
+const getRemoveToArraySuggestion = (toArrayCall, context, messageId, data) => {
+	const fix = getRemoveToArrayFix(toArrayCall, context);
+	if (!fix) {
+		return;
+	}
+
+	return {
+		messageId,
+		...(data && {data}),
+		fix,
+	};
+};
+
+const getArrayFromProblem = (node, context) => {
+	if (
+		!isMethodCall(node, {
+			objects: ['Array', ...typedArray],
+			method: 'from',
+			minimumArguments: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})
+		|| !isToArrayCall(node.arguments[0])
+	) {
+		return;
+	}
+
+	const toArrayCall = node.arguments[0];
+	const fix = getRemoveToArrayFix(toArrayCall, context);
+
+	return {
+		node: toArrayCall.callee.property,
+		messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
+		data: {description: `${node.callee.object.name}.${node.callee.property.name}(…)`},
+		...(fix && {fix}),
+	};
+};
+
+const getObjectFromEntriesProblem = (node, context) => {
+	if (
+		!isMethodCall(node, {
+			object: 'Object',
+			method: 'fromEntries',
+			minimumArguments: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})
+		|| !isToArrayCall(node.arguments[0])
+	) {
+		return;
+	}
+
+	const toArrayCall = node.arguments[0];
+	const fix = getRemoveToArrayFix(toArrayCall, context);
+
+	return {
+		node: toArrayCall.callee.property,
+		messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
+		data: {description: `${node.callee.object.name}.${node.callee.property.name}(…)`},
+		...(fix && {fix}),
+	};
+};
+
+const getPromiseProblem = (node, context) => {
+	// Suggestion only — passing an iterator directly can change a sync throw
+	// into an async rejection when iteration fails.
+	if (
+		!isMethodCall(node, {
+			object: 'Promise',
+			methods: ['all', 'allSettled', 'any', 'race'],
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})
+		|| !isToArrayCall(node.arguments[0])
+	) {
+		return;
+	}
+
+	const toArrayCall = node.arguments[0];
+	const suggestion = getRemoveToArraySuggestion(toArrayCall, context, MESSAGE_ID_SUGGESTION_ITERABLE_ACCEPTING);
+
+	return {
+		node: toArrayCall.callee.property,
+		messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
+		data: {description: `${node.callee.object.name}.${node.callee.property.name}(…)`},
+		...(suggestion && {suggest: [suggestion]}),
+	};
+};
+
+const getIteratorMethodProblem = (node, context) => {
+	if (
+		!(
+			isMethodCall(node, {
+				methods: callbackOnlyIteratorMethods,
+				maximumArguments: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			|| isMethodCall(node, {
+				method: reduceMethod,
+				argumentsLength: 2,
+				optionalCall: false,
+				optionalMember: false,
+			})
+		)
+		|| !isToArrayCall(node.callee.object)
+	) {
+		return;
+	}
+
+	// If the callback is a function/arrow with enough parameters to reference
+	// the `array` argument, `.toArray()` may be intentional.
+	const callback = node.arguments[0];
+	const method = node.callee.property.name;
+	const isReduceCall = method === reduceMethod;
+	const arrayParameterIndex = isReduceCall ? 3 : 2;
+	if (
+		callback
+		&& (callback.type === 'ArrowFunctionExpression' || callback.type === 'FunctionExpression')
+		&& (
+			callback.params.length > arrayParameterIndex
+			// A rest parameter can capture the trailing `array` argument too.
+			|| callback.params.at(-1)?.type === 'RestElement'
+		)
+	) {
+		return;
+	}
+
+	const toArrayCall = node.callee.object;
+	const suggestion = getRemoveToArraySuggestion(toArrayCall, context, MESSAGE_ID_SUGGESTION_ITERATOR_METHOD, {method});
+
+	return {
+		node: toArrayCall.callee.property,
+		messageId: MESSAGE_ID_ITERATOR_METHOD,
+		data: {method},
+		...(suggestion && {suggest: [suggestion]}),
+	};
+};
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	// Case 1: `new Set(iterator.toArray())`, `new Map(iterator.toArray())`, etc.
@@ -60,126 +208,22 @@ const create = context => {
 		}
 
 		const toArrayCall = node.arguments[0];
+		const fix = getRemoveToArrayFix(toArrayCall, context);
 
 		return {
 			node: toArrayCall.callee.property,
 			messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
 			data: {description: `new ${node.callee.name}(…)`},
-			fix: fixer => removeMethodCall(fixer, toArrayCall, context),
+			...(fix && {fix}),
 		};
 	});
 
 	// Case 2: Call expressions — static methods and iterator prototype methods.
-	context.on('CallExpression', node => {
-		// Case 2a: `Array.from(iterator.toArray())`, `TypedArray.from(…)`, `Object.fromEntries(…)`
-		// Autofix — these methods materialize their first argument into an array/object
-		// regardless of extra arguments (e.g. mapFn), so .toArray() is always unnecessary.
-		if (
-			(
-				isMethodCall(node, {
-					objects: ['Array', ...typedArray],
-					method: 'from',
-					minimumArguments: 1,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				|| isMethodCall(node, {
-					object: 'Object',
-					method: 'fromEntries',
-					minimumArguments: 1,
-					optionalCall: false,
-					optionalMember: false,
-				})
-			)
-			&& isToArrayCall(node.arguments[0])
-		) {
-			const toArrayCall = node.arguments[0];
-
-			return {
-				node: toArrayCall.callee.property,
-				messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
-				data: {description: `${node.callee.object.name}.${node.callee.property.name}(…)`},
-				fix: fixer => removeMethodCall(fixer, toArrayCall, context),
-			};
-		}
-
-		// Case 2b: `Promise.all(iterator.toArray())`, etc.
-		// Suggestion only — passing an iterator directly can change a sync throw
-		// into an async rejection when iteration fails.
-		if (
-			isMethodCall(node, {
-				object: 'Promise',
-				methods: ['all', 'allSettled', 'any', 'race'],
-				argumentsLength: 1,
-				optionalCall: false,
-				optionalMember: false,
-			})
-			&& isToArrayCall(node.arguments[0])
-		) {
-			const toArrayCall = node.arguments[0];
-
-			return {
-				node: toArrayCall.callee.property,
-				messageId: MESSAGE_ID_ITERABLE_ACCEPTING,
-				data: {description: `${node.callee.object.name}.${node.callee.property.name}(…)`},
-				suggest: [
-					{
-						messageId: MESSAGE_ID_SUGGESTION_ITERABLE_ACCEPTING,
-						fix: fixer => removeMethodCall(fixer, toArrayCall, context),
-					},
-				],
-			};
-		}
-
-		// Case 2c: `iterator.toArray().every(fn)`, `.find(fn)`, `.forEach(fn)`, `.some(fn)`, `.reduce(fn, init)`
-		// Suggestion only — Array callbacks receive a 3rd `array` argument
-		// (and `reduce` a 4th) that Iterator callbacks do not.
-		if (
-			(
-				isMethodCall(node, {
-					methods: callbackOnlyIteratorMethods,
-					maximumArguments: 1,
-					optionalCall: false,
-					optionalMember: false,
-				})
-				|| isMethodCall(node, {
-					method: reduceMethod,
-					argumentsLength: 2,
-					optionalCall: false,
-					optionalMember: false,
-				})
-			)
-			&& isToArrayCall(node.callee.object)
-		) {
-			// If the callback is a function/arrow with enough parameters to reference
-			// the `array` argument, `.toArray()` may be intentional.
-			const callback = node.arguments[0];
-			const isReduceCall = node.callee.property.name === reduceMethod;
-			const arrayParameterIndex = isReduceCall ? 3 : 2;
-			if (
-				callback
-				&& (callback.type === 'ArrowFunctionExpression' || callback.type === 'FunctionExpression')
-				&& callback.params.length > arrayParameterIndex
-			) {
-				return;
-			}
-
-			const callerObject = node.callee.object;
-
-			return {
-				node: callerObject.callee.property,
-				messageId: MESSAGE_ID_ITERATOR_METHOD,
-				data: {method: node.callee.property.name},
-				suggest: [
-					{
-						messageId: MESSAGE_ID_SUGGESTION_ITERATOR_METHOD,
-						data: {method: node.callee.property.name},
-						fix: fixer => removeMethodCall(fixer, callerObject, context),
-					},
-				],
-			};
-		}
-	});
+	context.on('CallExpression', node =>
+		getArrayFromProblem(node, context)
+		?? getObjectFromEntriesProblem(node, context)
+		?? getPromiseProblem(node, context)
+		?? getIteratorMethodProblem(node, context));
 
 	// Case 3: `for (const x of iterator.toArray())`
 	context.on('ForOfStatement', node => {
@@ -187,10 +231,12 @@ const create = context => {
 			return;
 		}
 
+		const fix = getRemoveToArrayFix(node.right, context);
+
 		return {
 			node: node.right.callee.property,
 			messageId: MESSAGE_ID_FOR_OF,
-			fix: fixer => removeMethodCall(fixer, node.right, context),
+			...(fix && {fix}),
 		};
 	});
 
@@ -200,10 +246,12 @@ const create = context => {
 			return;
 		}
 
+		const fix = getRemoveToArrayFix(node.argument, context);
+
 		return {
 			node: node.argument.callee.property,
 			messageId: MESSAGE_ID_YIELD_STAR,
-			fix: fixer => removeMethodCall(fixer, node.argument, context),
+			...(fix && {fix}),
 		};
 	});
 
@@ -223,10 +271,12 @@ const create = context => {
 			return;
 		}
 
+		const fix = getRemoveToArrayFix(node.argument, context);
+
 		return {
 			node: node.argument.callee.property,
 			messageId: MESSAGE_ID_SPREAD,
-			fix: fixer => removeMethodCall(fixer, node.argument, context),
+			...(fix && {fix}),
 		};
 	});
 };