eslint-plugin-unicorn 68.0.0 → 69.0.0

package/rules/prefer-dom-node-replace-children.js

@@ -0,0 +1,353 @@
+import {findVariable, getStaticValue} from '@eslint-community/eslint-utils';
+import {
+	getStaticStringValue,
+	isCallExpression,
+	isMemberExpression,
+	isMethodCall,
+} from './ast/index.js';
+import {
+	isKnownNonDomNode,
+	isGlobalIdentifier,
+	isNodeValueNotDomNode,
+	isSameReference,
+	isValueNotUsable,
+	mayBeHtmlTemplateElement,
+	needsSemicolon,
+	shouldAddParenthesesToMemberExpressionObject,
+	shouldReportReplaceChildrenReceiver,
+	unwrapTypeScriptExpression,
+	wouldRemoveComments,
+} from './utils/index.js';
+
+const MESSAGE_ID = 'prefer-dom-node-replace-children';
+const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+const globalObjectNames = new Set([
+	'frames',
+	'globalThis',
+	'parent',
+	'self',
+	'top',
+	'window',
+]);
+const messages = {
+	[MESSAGE_ID]: 'Prefer `{{replacement}}` over manually emptying DOM children.',
+};
+
+const getStaticString = node => getStaticStringValue(unwrapTypeScriptExpression(node));
+
+const getStaticStringValueFromScope = (node, context) => {
+	node = unwrapTypeScriptExpression(node);
+
+	const string = getStaticStringValue(node);
+	if (string !== undefined) {
+		return string;
+	}
+
+	const result = getStaticValue(node, context.sourceCode.getScope(node));
+	return typeof result?.value === 'string' ? result.value : undefined;
+};
+
+const getConstIdentifierInitializer = (node, context, visitedVariables) => {
+	if (node.type !== 'Identifier') {
+		return;
+	}
+
+	const variable = findVariable(context.sourceCode.getScope(node), node);
+	if (
+		!variable
+		|| visitedVariables.has(variable)
+		|| variable.defs.length !== 1
+	) {
+		return;
+	}
+
+	const [definition] = variable.defs;
+	if (
+		definition.type !== 'Variable'
+		|| definition.parent.kind !== 'const'
+		|| definition.node.id !== definition.name
+	) {
+		return;
+	}
+
+	visitedVariables.add(variable);
+	return definition.node.init;
+};
+
+const getStaticPropertyName = memberExpression => {
+	const {property} = memberExpression;
+
+	if (
+		!memberExpression.computed
+		&& property.type === 'Identifier'
+	) {
+		return property.name;
+	}
+
+	return getStaticString(property);
+};
+
+const isInnerHTMLMemberExpression = node =>
+	isMemberExpression(node)
+	&& getStaticPropertyName(node) === 'innerHTML';
+
+const isEmptyString = node => getStaticString(node) === '';
+
+const isStaticMethodCall = (node, method, options) =>
+	isCallExpression(node, {
+		...options,
+		optional: false,
+	})
+	&& isMemberExpression(node.callee, {optional: false})
+	&& getStaticPropertyName(node.callee) === method;
+
+const isGlobalDocument = (node, context, visitedVariables = new Set()) => {
+	node = unwrapTypeScriptExpression(node);
+
+	const initializer = getConstIdentifierInitializer(node, context, visitedVariables);
+	if (initializer) {
+		return isGlobalDocument(initializer, context, visitedVariables);
+	}
+
+	if (
+		node.type === 'Identifier'
+		&& node.name === 'document'
+	) {
+		return isGlobalIdentifier(node, context);
+	}
+
+	return isMemberExpression(node, {optional: false})
+		&& getStaticPropertyName(node) === 'document'
+		&& node.object.type === 'Identifier'
+		&& globalObjectNames.has(node.object.name)
+		&& isGlobalIdentifier(node.object, context);
+};
+
+const isUnknownOrHtmlNamespace = (node, context) => {
+	node = unwrapTypeScriptExpression(node);
+
+	const string = getStaticStringValue(node);
+	if (string !== undefined) {
+		return string === HTML_NAMESPACE;
+	}
+
+	const result = getStaticValue(node, context.sourceCode.getScope(node));
+	return !result || result.value === HTML_NAMESPACE;
+};
+
+const mayCreateHtmlTemplateElement = (node, context, visitedVariables = new Set()) => {
+	node = unwrapTypeScriptExpression(node);
+
+	const initializer = getConstIdentifierInitializer(node, context, visitedVariables);
+	if (initializer) {
+		return mayCreateHtmlTemplateElement(initializer, context, visitedVariables);
+	}
+
+	if (
+		isStaticMethodCall(node, 'createElement', {
+			minimumArguments: 1,
+			maximumArguments: 2,
+		})
+	) {
+		return getStaticStringValueFromScope(node.arguments[0], context)?.toLowerCase() === 'template';
+	}
+
+	if (
+		!isStaticMethodCall(node, 'createElementNS', {
+			minimumArguments: 2,
+			maximumArguments: 3,
+		})
+		|| getStaticStringValueFromScope(node.arguments[1], context)?.toLowerCase() !== 'template'
+	) {
+		return false;
+	}
+
+	return isUnknownOrHtmlNamespace(node.arguments[0], context);
+};
+
+const getOnlyBodyStatement = node => {
+	if (node.body.type !== 'BlockStatement') {
+		return node.body;
+	}
+
+	return node.body.body.length === 1
+		? node.body.body[0]
+		: undefined;
+};
+
+const getChildNodeMemberExpression = node => {
+	if (
+		isMemberExpression(node, {
+			properties: ['firstChild', 'lastChild'],
+			optional: false,
+		})
+	) {
+		return node;
+	}
+};
+
+const containsChainExpression = (node, sourceCode) => {
+	if (node.type === 'ChainExpression') {
+		return true;
+	}
+
+	const keys = sourceCode.visitorKeys[node.type] ?? [];
+	for (const key of keys) {
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const childNode of child) {
+				if (childNode && containsChainExpression(childNode, sourceCode)) {
+					return true;
+				}
+			}
+
+			continue;
+		}
+
+		if (child && containsChainExpression(child, sourceCode)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+const getParentNodeText = (parentNode, context) => {
+	const {sourceCode} = context;
+
+	return (
+		parentNode.type !== 'Super'
+		&& shouldAddParenthesesToMemberExpressionObject(parentNode, context)
+	)
+		? `(${sourceCode.getText(parentNode)})`
+		: sourceCode.getText(parentNode);
+};
+
+const getReplaceChildrenStatement = (node, parentNode, context) => {
+	const parentNodeText = getParentNodeText(parentNode, context);
+	return `${needsSemicolon(context.sourceCode.getTokenBefore(node), context, parentNodeText) ? ';' : ''}${parentNodeText}.replaceChildren();`;
+};
+
+const shouldSkipParentNode = (parentNode, context, options) => {
+	const {sourceCode} = context;
+
+	return isNodeValueNotDomNode(parentNode)
+		|| isKnownNonDomNode(parentNode, context, {
+			allowNullishInMixedUnion: true,
+			treatMixedUnionAsNonTarget: true,
+		})
+		|| containsChainExpression(parentNode, sourceCode)
+		|| !shouldReportReplaceChildrenReceiver(context, parentNode, options);
+};
+
+const shouldSkipInnerHTMLParentNode = (parentNode, context) =>
+	shouldSkipParentNode(parentNode, context, {checkInnerHTML: true});
+
+const getInnerHTMLProblem = (context, node) => {
+	if (
+		node.operator !== '='
+		|| !isInnerHTMLMemberExpression(node.left)
+		|| !isEmptyString(node.right)
+	) {
+		return;
+	}
+
+	const parentNode = node.left.object;
+	if (
+		shouldSkipInnerHTMLParentNode(parentNode, context)
+		|| isGlobalDocument(parentNode, context)
+		|| mayCreateHtmlTemplateElement(parentNode, context)
+		|| mayBeHtmlTemplateElement(context, parentNode)
+	) {
+		return;
+	}
+
+	const replacement = getReplaceChildrenStatement(node.parent, parentNode, context);
+	const fix = (
+		node.parent.type === 'ExpressionStatement'
+		&& isValueNotUsable(node)
+		&& !wouldRemoveComments(context, node.parent, [parentNode])
+	)
+		? fixer => fixer.replaceText(node.parent, replacement)
+		: undefined;
+
+	return {
+		node: node.left.property,
+		messageId: MESSAGE_ID,
+		data: {
+			replacement: `${getParentNodeText(parentNode, context)}.replaceChildren()`,
+		},
+		fix,
+	};
+};
+
+const getRemoveChildLoopProblem = (context, node) => {
+	const childNode = getChildNodeMemberExpression(node.test);
+	if (!childNode) {
+		return;
+	}
+
+	const bodyStatement = getOnlyBodyStatement(node);
+	if (bodyStatement?.type !== 'ExpressionStatement') {
+		return;
+	}
+
+	const {expression} = bodyStatement;
+	if (
+		!isMethodCall(expression, {
+			method: 'removeChild',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})
+		|| !isSameReference(childNode.object, expression.callee.object)
+		|| !isSameReference(childNode, expression.arguments[0])
+	) {
+		return;
+	}
+
+	const parentNode = childNode.object;
+	if (shouldSkipParentNode(parentNode, context)) {
+		return;
+	}
+
+	const replacement = getReplaceChildrenStatement(node, parentNode, context);
+	const fix = wouldRemoveComments(context, node, [parentNode])
+		? undefined
+		: fixer => fixer.replaceText(node, replacement);
+
+	return {
+		node,
+		messageId: MESSAGE_ID,
+		data: {
+			replacement: `${getParentNodeText(parentNode, context)}.replaceChildren()`,
+		},
+		fix,
+	};
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('AssignmentExpression', node => getInnerHTMLProblem(context, node));
+	context.on('WhileStatement', node => getRemoveChildLoopProblem(context, node));
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `.replaceChildren()` when emptying DOM children.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		schema: [],
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/prefer-error-is-error.js

@@ -0,0 +1,181 @@
+import {isMemberExpression, isMethodCall} from './ast/index.js';
+import {isTypeImportSpecifier} from './utils/index.js';
+
+const MESSAGE_ID = 'prefer-error-is-error';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `Error.isError(…)`.',
+};
+
+const isTypeImport = definition =>
+	definition.type === 'ImportBinding'
+	&& isTypeImportSpecifier(definition.node);
+
+const isTypeOnlyDefinition = definition =>
+	definition.type === 'Type'
+	|| isTypeImport(definition);
+
+function isValueShadowed(node, name, context) {
+	let scope = context.sourceCode.getScope(node);
+
+	while (scope) {
+		const variable = scope.set.get(name);
+
+		if (variable?.defs.some(definition => !isTypeOnlyDefinition(definition))) {
+			return true;
+		}
+
+		scope = scope.upper;
+	}
+
+	return false;
+}
+
+const isGlobalError = (node, context) =>
+	node.type === 'Identifier'
+	&& node.name === 'Error'
+	&& !isValueShadowed(node, 'Error', context);
+
+const isGlobalObject = (node, context) =>
+	node.type === 'Identifier'
+	&& node.name === 'Object'
+	&& !isValueShadowed(node, 'Object', context);
+
+const isErrorTagLiteral = node =>
+	node.type === 'Literal'
+	&& node.value === '[object Error]';
+
+const supportedComparisonOperators = new Set([
+	'===',
+	'!==',
+	'==',
+	'!=',
+]);
+
+const isObjectPrototypeToString = (node, context) =>
+	isMemberExpression(node, {property: 'toString', optional: false})
+	&& isMemberExpression(node.object, {property: 'prototype', optional: false})
+	&& isGlobalObject(node.object.object, context);
+
+const isEmptyObjectToString = node =>
+	isMemberExpression(node, {property: 'toString', optional: false})
+	&& node.object.type === 'ObjectExpression'
+	&& node.object.properties.length === 0;
+
+const getToStringCallArgument = (node, context) => {
+	if (
+		!isMethodCall(node, {
+			method: 'call',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})
+	) {
+		return;
+	}
+
+	const method = node.callee.object;
+	if (
+		isObjectPrototypeToString(method, context)
+		|| isEmptyObjectToString(method)
+	) {
+		return node.arguments[0];
+	}
+};
+
+const getErrorTagComparison = (node, context) => {
+	if (!supportedComparisonOperators.has(node.operator)) {
+		return;
+	}
+
+	if (isErrorTagLiteral(node.right)) {
+		const argument = getToStringCallArgument(node.left, context);
+		if (argument) {
+			return argument;
+		}
+	}
+
+	if (isErrorTagLiteral(node.left)) {
+		const argument = getToStringCallArgument(node.right, context);
+		if (argument) {
+			return argument;
+		}
+	}
+};
+
+const hasComments = (node, sourceCode) =>
+	sourceCode.getCommentsInside(node).length > 0;
+
+const getArgumentText = (node, sourceCode) => {
+	const text = sourceCode.getText(node);
+	return node.type === 'SequenceExpression' ? `(${text})` : text;
+};
+
+const createFix = ({node, argument, negate}, context) =>
+	fixer => fixer.replaceText(
+		node,
+		`${negate ? '!' : ''}Error.isError(${getArgumentText(argument, context.sourceCode)})`,
+	);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('BinaryExpression', node => {
+		if (hasComments(node, context.sourceCode)) {
+			return;
+		}
+
+		if (
+			node.operator === 'instanceof'
+			&& isGlobalError(node.right, context)
+		) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+				fix: createFix({
+					node,
+					argument: node.left,
+					negate: false,
+				}, context),
+			};
+		}
+
+		const argument = getErrorTagComparison(node, context);
+		if (
+			!argument
+			|| isValueShadowed(node, 'Error', context)
+		) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			fix: createFix({
+				node,
+				argument,
+				negate: node.operator === '!==' || node.operator === '!=',
+			}, context),
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Error.isError()` when checking for errors.',
+			// eslint-disable-next-line no-warning-comments
+			// TODO: Enable in the `recommended` config when `Error.isError()` is Baseline and the project targets Node.js >=24.
+			recommended: false,
+		},
+		fixable: 'code',
+		schema: [],
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/prefer-has-check.js

@@ -39,10 +39,7 @@ const definitelyTruthyBuiltinTypeNames = new Set([
 	'ReadonlyArray',
 ]);
 
-const constructibleCollectionTypeNames = new Set([
-	...mapConstructorTypeNames,
-	...nullSentinelTypeNames,
-]);
+const constructibleCollectionTypeNames = mapConstructorTypeNames.union(nullSentinelTypeNames);
 
 const typeReferenceDefinitionTypes = new Set([
 	'ClassName',

package/rules/prefer-hoisting-branch-code.js

@@ -29,11 +29,9 @@ const isElseIfStatement = node =>
 	node.parent.type === 'IfStatement'
 	&& node.parent.alternate === node;
 
-function hasSideEffectOrTaggedTemplate(node, sourceCode) {
-	if (
-		node.type === 'TaggedTemplateExpression'
-		|| hasSideEffect(node, sourceCode)
-	) {
+// `hasSideEffect` does not treat a tagged template as a call, so check for one separately.
+function containsTaggedTemplate(node, sourceCode) {
+	if (node.type === 'TaggedTemplateExpression') {
 		return true;
 	}
 
@@ -42,7 +40,7 @@ function hasSideEffectOrTaggedTemplate(node, sourceCode) {
 		const child = node[key];
 		if (Array.isArray(child)) {
 			for (const childNode of child) {
-				if (childNode && hasSideEffectOrTaggedTemplate(childNode, sourceCode)) {
+				if (childNode && containsTaggedTemplate(childNode, sourceCode)) {
 					return true;
 				}
 			}
@@ -50,7 +48,7 @@ function hasSideEffectOrTaggedTemplate(node, sourceCode) {
 			continue;
 		}
 
-		if (child && hasSideEffectOrTaggedTemplate(child, sourceCode)) {
+		if (child && containsTaggedTemplate(child, sourceCode)) {
 			return true;
 		}
 	}
@@ -58,6 +56,10 @@ function hasSideEffectOrTaggedTemplate(node, sourceCode) {
 	return false;
 }
 
+const hasSideEffectOrTaggedTemplate = (node, sourceCode) =>
+	hasSideEffect(node, sourceCode)
+	|| containsTaggedTemplate(node, sourceCode);
+
 // Tokens of a statement, ignoring a trailing semicolon so ASI differences don't matter.
 const getStatementTokens = (node, sourceCode) => {
 	const tokens = sourceCode.getTokens(node);

package/rules/prefer-iterator-concat.js

@@ -1,5 +1,9 @@
 import typedArray from './shared/typed-array.js';
-import {getParenthesizedText} from './utils/index.js';
+import {
+	getParenthesizedText,
+	isBuiltinSet,
+	isGlobalIdentifier,
+} from './utils/index.js';
 import {
 	isMethodCall,
 	isNewExpression,
@@ -89,6 +93,21 @@ const isToArrayCall = node => isMethodCall(node, {
 const hasToArraySpreadElement = arrayExpression =>
 	arrayExpression.elements.some(element => isToArrayCall(element.argument));
 
+const isKnownSetUnionCase = (arrayExpression, context) => {
+	const {parent} = arrayExpression;
+
+	return (
+		isNewExpression(parent, {
+			name: 'Set',
+			argumentsLength: 1,
+		})
+		&& parent.arguments[0] === arrayExpression
+		&& isGlobalIdentifier(parent.callee, context)
+		&& context.sourceCode.getCommentsInside(parent).length === 0
+		&& arrayExpression.elements.every(element => isBuiltinSet(element.argument, context))
+	);
+};
+
 const isSuggestionOnlyParent = parent =>
 	(parent.type === 'ForOfStatement' || (parent.type === 'YieldExpression' && parent.delegate))
 	|| (
@@ -119,6 +138,7 @@ const create = context => {
 			!isSpreadArray(node)
 			|| !isInIterableAcceptingParent(node)
 			|| hasToArraySpreadElement(node)
+			|| isKnownSetUnionCase(node, context)
 		) {
 			return;
 		}

package/rules/prefer-minimal-ternary.js

@@ -89,11 +89,11 @@ function hasSameStaticPropertyWithDifferentObject(left, right, context) {
 		&& !isSameSourceText(left.object, right.object, sourceCode);
 }
 
-function hasMinimalCalleeDifference(left, right, context, checkComputedMemberAccess) {
-	// Only `hasSameObjectWithDifferentStaticProperty` is opt-in: it produces computed member access (`obj[test ? 'a' : 'b'](…)`). The other branches keep plain identifier or dot access.
-	return isDifferentIdentifier(left, right)
+function hasMinimalCalleeDifference(left, right, context, {checkVaryingCallee, checkComputedMemberAccess}) {
+	// All callee-varying call cases push the ternary in front of the call (`(test ? a : b)()`), hiding the call site, so they are opt-in. `checkVaryingCallee` covers plain identifier and dot access; `checkComputedMemberAccess` additionally produces computed member access (`obj[test ? 'a' : 'b'](…)`).
+	return (checkVaryingCallee && isDifferentIdentifier(left, right))
 		|| (checkComputedMemberAccess && hasSameObjectWithDifferentStaticProperty(left, right, context))
-		|| hasSameStaticPropertyWithDifferentObject(left, right, context);
+		|| (checkVaryingCallee && hasSameStaticPropertyWithDifferentObject(left, right, context));
 }
 
 function hasOneMinimalItemDifference(leftItems, rightItems, sourceCode) {
@@ -125,7 +125,7 @@ function hasSameItems(leftItems, rightItems, sourceCode) {
 		&& leftItems.every((leftItem, index) => isSameSourceText(leftItem, rightItems[index], sourceCode));
 }
 
-function isMinimalCallExpression(left, right, context, checkComputedMemberAccess) {
+function isMinimalCallExpression(left, right, context, options) {
 	const {sourceCode} = context;
 
 	if (
@@ -148,7 +148,7 @@ function isMinimalCallExpression(left, right, context, checkComputedMemberAccess
 	}
 
 	return hasSameItems(left.arguments, right.arguments, sourceCode)
-		&& hasMinimalCalleeDifference(left.callee, right.callee, context, checkComputedMemberAccess);
+		&& hasMinimalCalleeDifference(left.callee, right.callee, context, options);
 }
 
 function isPrivateBrandCheck(node) {
@@ -205,7 +205,7 @@ function isMinimalMemberExpression(left, right, context) {
 		|| hasSameObjectWithDifferentDynamicKey(left, right, context);
 }
 
-function isMinimalTernary(consequent, alternate, context, checkComputedMemberAccess) {
+function isMinimalTernary(consequent, alternate, context, options) {
 	if (
 		consequent.type !== alternate.type
 		|| isIgnoredExpression(consequent)
@@ -214,17 +214,17 @@ function isMinimalTernary(consequent, alternate, context, checkComputedMemberAcc
 		return false;
 	}
 
-	return isMinimalCallExpression(consequent, alternate, context, checkComputedMemberAccess)
+	return isMinimalCallExpression(consequent, alternate, context, options)
 		|| isMinimalBinaryExpression(consequent, alternate, context)
 		|| isMinimalMemberExpression(consequent, alternate, context);
 }
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const {checkComputedMemberAccess} = context.options[0];
+	const options = context.options[0];
 
 	context.on('ConditionalExpression', node => {
-		if (!isMinimalTernary(node.consequent, node.alternate, context, checkComputedMemberAccess)) {
+		if (!isMinimalTernary(node.consequent, node.alternate, context, options)) {
 			return;
 		}
 
@@ -249,6 +249,10 @@ const config = {
 				type: 'object',
 				additionalProperties: false,
 				properties: {
+					checkVaryingCallee: {
+						type: 'boolean',
+						description: 'Also report call ternaries that differ only by the callee, whose minimization moves the ternary in front of the call.',
+					},
 					checkComputedMemberAccess: {
 						type: 'boolean',
 						description: 'Also report method-call ternaries that differ only by the method name, whose minimization requires computed member access.',
@@ -256,7 +260,7 @@ const config = {
 				},
 			},
 		],
-		defaultOptions: [{checkComputedMemberAccess: false}],
+		defaultOptions: [{checkVaryingCallee: false, checkComputedMemberAccess: false}],
 		messages,
 		languages: [
 			'js/js',