eslint-plugin-unicorn 67.0.0 → 69.0.0

package/rules/better-dom-traversing.js

@@ -4,7 +4,12 @@ import {
 	isMemberExpression,
 	isNumericLiteral,
 } from './ast/index.js';
-import {escapeString, getParenthesizedText, isNodeValueNotDomNode} from './utils/index.js';
+import {
+	escapeString,
+	getParenthesizedRange,
+	getParenthesizedText,
+	isNodeValueNotDomNode,
+} from './utils/index.js';
 
 const MESSAGE_ID_FIRST_CHILD = 'first-child';
 const MESSAGE_ID_FIRST_ELEMENT_CHILD = 'first-element-child';
@@ -87,18 +92,24 @@ const isNestedIndexedDomCollection = node =>
 const hasCommentsInside = (node, sourceCode) =>
 	sourceCode.getCommentsInside(node).length > 0;
 
-const getFirstChildSuggestion = (node, replacement, messageId, sourceCode) => {
+const getFirstChildSuggestion = (node, replacement, messageId, context) => {
+	const {sourceCode} = context;
 	if (hasCommentsInside(node, sourceCode)) {
 		return;
 	}
 
+	// Replace the property name (`childNodes`/`children`) and drop the `[index]` access
+	// separately, so parentheses around the collection (e.g. `(element.childNodes)[0]`) are preserved.
+	const [, objectEnd] = getParenthesizedRange(node.object, context);
 	const [, end] = sourceCode.getRange(node);
-	const [start] = sourceCode.getRange(node.object.property);
 
 	return [
 		{
 			messageId,
-			fix: fixer => fixer.replaceTextRange([start, end], replacement),
+			fix: fixer => [
+				fixer.replaceText(node.object.property, replacement),
+				fixer.removeRange([objectEnd, end]),
+			],
 		},
 	];
 };
@@ -222,8 +233,6 @@ const getMergeQuerySelectorSuggestion = (node, querySelectorChain, context) => {
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const {sourceCode} = context;
-
 	context.on('MemberExpression', node => {
 		const collectionName = getIndexedDomCollectionName(node);
 		if (
@@ -243,7 +252,7 @@ const create = context => {
 			return {
 				node,
 				messageId: MESSAGE_ID_FIRST_CHILD,
-				suggest: getFirstChildSuggestion(node, 'firstChild', SUGGESTION_ID_FIRST_CHILD, sourceCode),
+				suggest: getFirstChildSuggestion(node, 'firstChild', SUGGESTION_ID_FIRST_CHILD, context),
 			};
 		}
 
@@ -251,7 +260,7 @@ const create = context => {
 			return {
 				node,
 				messageId: MESSAGE_ID_FIRST_ELEMENT_CHILD,
-				suggest: getFirstChildSuggestion(node, 'firstElementChild', SUGGESTION_ID_FIRST_ELEMENT_CHILD, sourceCode),
+				suggest: getFirstChildSuggestion(node, 'firstElementChild', SUGGESTION_ID_FIRST_ELEMENT_CHILD, context),
 			};
 		}
 

package/rules/class-reference-in-static-methods.js

@@ -92,6 +92,12 @@ const isSameVariable = (sourceCode, reference, binding) =>
 	findVariable(sourceCode.getScope(reference), reference)
 	=== findVariable(sourceCode.getScope(binding), binding);
 
+// Whether the class/superclass name resolves to the class binding at `node`'s location.
+// If it's shadowed by a local variable, the name can't be used to reference the class.
+const isReferenceNameAvailable = (sourceCode, node, referenceNode) =>
+	findVariable(sourceCode.getScope(node), referenceNode.name)
+	=== findVariable(sourceCode.getScope(referenceNode), referenceNode);
+
 const isAssignmentTargetRoot = (parent, node) =>
 	(
 		parent.type === 'AssignmentExpression'
@@ -331,7 +337,10 @@ const create = context => {
 		}
 
 		const classReferenceNode = getClassReferenceNode(getClass(staticMethod));
-		if (!classReferenceNode) {
+		if (
+			!classReferenceNode
+			|| !isReferenceNameAvailable(sourceCode, node, classReferenceNode)
+		) {
 			return problemWithoutSuggestion(node, MESSAGE_ID_CLASS_UNAVAILABLE);
 		}
 
@@ -355,7 +364,10 @@ const create = context => {
 		}
 
 		const superClassReferenceNode = getSimpleSuperClassReferenceNode(getClass(staticMethod));
-		if (!superClassReferenceNode) {
+		if (
+			!superClassReferenceNode
+			|| !isReferenceNameAvailable(sourceCode, node, superClassReferenceNode)
+		) {
 			return problemWithoutSuggestion(node, MESSAGE_ID_SUPER_CLASS_UNAVAILABLE);
 		}
 

package/rules/comment-content.js

@@ -285,8 +285,11 @@ const listMarkerPatternSource = String.raw`(?:[*+\-]|\d+\.)`;
 const optionalListMarkerPrefixPatternSource = String.raw`${listMarkerPatternSource}?\s*`;
 const optionalLabelPrefixPatternSource = String.raw`(?:${identifierPatternSource}:\s*)?`;
 const bracketPropertyPatternSource = String.raw`\[[^\]]+\]`;
-const optionalAssignmentPrefixPatternSource = String.raw`(?:${identifierPatternSource}(?::|\s*=)\s*)?`;
 const memberCallPropertyPatternSource = String.raw`(?:(?:\?\.|\.)\s*${identifierPatternSource}|\??\.\s*${bracketPropertyPatternSource})`;
+const memberAssignmentTargetPatternSource = String.raw`${identifierPatternSource}(?:\s*${memberCallPropertyPatternSource}|\s*${bracketPropertyPatternSource})+`;
+const optionalDeclarationPrefixPatternSource = String.raw`(?:(?:const|let|var)\s+)?`;
+const assignmentTargetPatternSource = `(?:${identifierPatternSource}|${memberAssignmentTargetPatternSource})`;
+const optionalAssignmentPrefixPatternSource = String.raw`(?:(?:${identifierPatternSource}:|${optionalDeclarationPrefixPatternSource}${assignmentTargetPatternSource}\s*=)\s*)?`;
 const markdownLinkDestinationStartPatternSource = String.raw`(?:[A-Za-z][\d+\-.A-Za-z]*:\/\/|www\.|[\u{2D}0-9A-Za-z]+\.|[\w\-.]+\/|\/|#)`;
 const callArgumentsPatternSource = String.raw`\((?!\s*${markdownLinkDestinationStartPatternSource})[^\)]*\)`;
 const bracketMemberAccessLinePattern = new RegExp([
@@ -325,6 +328,14 @@ const memberCallLinePattern = new RegExp([
 	String.raw`\s*${memberCallPropertyPatternSource}\s*(?:\?\.\s*)?\(`,
 	String.raw`|${bracketPropertyPatternSource}\()`,
 ].join(''), 'v');
+const bareCallLinePattern = new RegExp([
+	`^${optionalListMarkerPrefixPatternSource}`,
+	String.raw`(?:\(\s*)?`,
+	optionalAssignmentPrefixPatternSource,
+	String.raw`(?:new\s+)?`,
+	codeIdentifierPatternSource,
+	String.raw`(?:\(|\s+\(\s*$)`,
+].join(''), 'v');
 const shellPromptLinePattern = new RegExp(String.raw`^${optionalListMarkerPrefixPatternSource}\$\s+\S+`, 'v');
 const secondaryShellPromptLinePattern = new RegExp(String.raw`^${optionalListMarkerPrefixPatternSource}>\s*(?:bun|curl|deno|docker|git|node(?:js)?|npm|npx|pnpm|yarn)\b`, 'v');
 const listMarkerPattern = new RegExp(String.raw`^${listMarkerPatternSource}\s*`, 'v');
@@ -336,6 +347,55 @@ const packageSpecifierTerminatorCharacters = '"\'`()[]{}<>,';
 const domainLeadingPunctuation = '([{<';
 const domainTrailingPunctuation = '.,;:!?)]}>';
 const maskCharacter = '\uFFFF';
+const openBrackets = '([{';
+const closeBrackets = ')]}';
+const quoteCharacters = '"\'`';
+
+// Count the net change in unbalanced brackets across a line, ignoring brackets inside string literals so they do not miscount. Operates on raw text so it is independent of mask ordering.
+function getBracketDepthDelta(text) {
+	let delta = 0;
+	let quote;
+
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+
+		if (quote) {
+			if (character === '\\') {
+				index++;
+				continue;
+			}
+
+			if (character === quote) {
+				quote = undefined;
+			}
+
+			continue;
+		}
+
+		if (character === '/' && text[index + 1] === '/') {
+			break;
+		}
+
+		if (character === '/' && text[index + 1] === '*') {
+			const endIndex = text.indexOf('*/', index + 2);
+			index = endIndex === -1 ? text.length : endIndex + 1;
+			continue;
+		}
+
+		if (quoteCharacters.includes(character)) {
+			quote = character;
+			continue;
+		}
+
+		if (openBrackets.includes(character)) {
+			delta++;
+		} else if (closeBrackets.includes(character)) {
+			delta--;
+		}
+	}
+
+	return delta;
+}
 
 function isIdentifierLikeCharacter(character) {
 	return Boolean(character) && /[\p{Letter}\p{Number}_]/v.test(character);
@@ -716,14 +776,48 @@ function isIgnoredCommentLine(line) {
 		|| memberCallLinePattern.test(removeMarkdownInlineLinks(line));
 }
 
+function getBracketContinuationOpeningDepth(line) {
+	line = cleanCommentLine(line);
+	line = removeMarkdownInlineLinks(line);
+
+	if (!bareCallLinePattern.test(line) && !memberCallLinePattern.test(line)) {
+		return 0;
+	}
+
+	return Math.max(0, getBracketDepthDelta(line));
+}
+
+// Advance the running bracket depth for one line. A line counts as code if depth is already open (a continuation line) or it looks like code on its own; otherwise depth resets to zero.
+function getNextBracketDepth(depth, line) {
+	if (depth > 0) {
+		return Math.max(0, depth + getBracketDepthDelta(line));
+	}
+
+	return getBracketContinuationOpeningDepth(line);
+}
+
 function maskIgnoredLines(characters, text) {
 	let start = 0;
+	let depth = 0;
 
 	while (start < text.length) {
 		const end = getLineEndIndex(text, start);
+		const line = text.slice(start, end);
+
+		if (characters.slice(start, end).includes(maskCharacter)) {
+			depth = 0;
+			start = end + 1;
+			continue;
+		}
 
-		if (isIgnoredCommentLine(text.slice(start, end))) {
+		const openingDepth = getBracketContinuationOpeningDepth(line);
+
+		// A line is masked if it looks like code on its own, or if it is a continuation line inside brackets opened by an earlier code-like line.
+		if (depth > 0 || isIgnoredCommentLine(line) || openingDepth > 0) {
 			maskRange(characters, start, end);
+			depth = depth > 0
+				? Math.max(0, depth + getBracketDepthDelta(line))
+				: openingDepth;
 		}
 
 		start = end + 1;
@@ -980,29 +1074,53 @@ const create = context => {
 		const {sourceCode} = context;
 		const comments = getRuleComments(context);
 
+		// Carry bracket depth across adjacent line comments so that a commented-out multi-line code construct spanning several `//` comments is not rewritten on its continuation lines.
+		let continuationDepth = 0;
+		let previousLineCommentRangeEnd;
+
 		for (const comment of comments) {
 			if (comment.type === 'Shebang' || isEslintDirective(context, comment)) {
+				continuationDepth = 0;
+				previousLineCommentRangeEnd = undefined;
 				continue;
 			}
 
-			const problem = getReplacementProblem(comment, sourceCode, replacements, checkUniformCase);
-			if (!problem) {
-				continue;
+			const range = sourceCode.getRange(comment);
+			const isAdjacentLineComment = comment.type === 'Line'
+				&& previousLineCommentRangeEnd !== undefined
+				&& /^[^\S\n]*\n[^\S\n]*$/v.test(sourceCode.text.slice(previousLineCommentRangeEnd, range[0]));
+
+			if (!isAdjacentLineComment) {
+				continuationDepth = 0;
 			}
 
-			yield {
-				node,
-				loc: {
-					start: sourceCode.getLocFromIndex(problem.replacementRange[0]),
-					end: sourceCode.getLocFromIndex(problem.replacementRange[1]),
-				},
-				messageId: MESSAGE_ID,
-				data: {
-					value: problem.value,
-					replacement: problem.replacement,
-				},
-				fix: fixer => fixer.replaceTextRange(problem.replacementRange, problem.replacement),
-			};
+			if (continuationDepth <= 0) {
+				const problem = getReplacementProblem(comment, sourceCode, replacements, checkUniformCase);
+				if (problem) {
+					yield {
+						node,
+						loc: {
+							start: sourceCode.getLocFromIndex(problem.replacementRange[0]),
+							end: sourceCode.getLocFromIndex(problem.replacementRange[1]),
+						},
+						messageId: MESSAGE_ID,
+						data: {
+							value: problem.value,
+							replacement: problem.replacement,
+						},
+						fix: fixer => fixer.replaceTextRange(problem.replacementRange, problem.replacement),
+					};
+				}
+			}
+
+			// Update continuation state for the next adjacent line comment.
+			if (comment.type === 'Line') {
+				continuationDepth = getNextBracketDepth(continuationDepth, comment.value);
+				previousLineCommentRangeEnd = range[1];
+			} else {
+				continuationDepth = 0;
+				previousLineCommentRangeEnd = undefined;
+			}
 		}
 	});
 };

package/rules/consistent-assert.js

@@ -60,7 +60,7 @@ const create = context => {
 			const variables = context.sourceCode.getDeclaredVariables(specifier);
 
 			/* c8 ignore next 3 */
-			if (!Array.isArray(variables) && variables.length === 1) {
+			if (!Array.isArray(variables) || variables.length !== 1) {
 				continue;
 			}
 

package/rules/consistent-boolean-name.js

@@ -1,3 +1,4 @@
+import {isRegExp} from 'node:util/types';
 import {getPropertyName} from '@eslint-community/eslint-utils';
 import {renameVariable} from './fix/index.js';
 import {
@@ -23,10 +24,13 @@ const messages = {
 
 const defaultPrefixes = {
 	is: true,
+	are: true,
 	has: true,
+	have: true,
 	can: true,
 	should: true,
 	was: true,
+	were: true,
 	did: true,
 	will: true,
 };
@@ -83,11 +87,22 @@ function findParameter(parameters, identifier) {
 const prepareOptions = ({
 	checkProperties = false,
 	prefixes = {},
+	ignore = [],
 } = {}) => ({
 	checkProperties,
 	prefixes: getEnabledPrefixes({prefixes}),
+	ignore: ignore.map(pattern => isRegExp(pattern) ? pattern : new RegExp(pattern, 'u')),
 });
 
+function isIgnoredName(name, ignore) {
+	return ignore.some(regexp => {
+		regexp.lastIndex = 0;
+		const isIgnored = regexp.test(name);
+		regexp.lastIndex = 0;
+		return isIgnored;
+	});
+}
+
 function hasBooleanPrefix(name, prefixes) {
 	name = stripLeadingUnderscores(name);
 
@@ -198,6 +213,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) {
@@ -206,6 +231,11 @@ const isBooleanVariable = (variable, context) => {
 	}
 
 	if (definition.type === 'Parameter') {
+		// Some parsers (such as Svelte's `{#each}` bindings) create `Parameter` definitions whose owner is not a function and has no `params` list.
+		if (!isFunction(definition.node)) {
+			return false;
+		}
+
 		const parameter = findParameter(definition.node.params, name);
 
 		return parameter?.type === 'AssignmentPattern'
@@ -377,16 +407,19 @@ function getAutofix(variable, prefixes, context, suggestions) {
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	const {checkProperties, prefixes} = prepareOptions(context.options[0]);
+	const {checkProperties, prefixes, ignore} = prepareOptions(context.options[0]);
 
 	if (prefixes.length === 0) {
 		return;
 	}
 
 	const checkVariable = variable => {
+		// `hasBooleanPrefix` and `ignore` are cheap string checks, so run them before
+		// the expensive `isBooleanVariable` analysis.
 		if (
-			!isBooleanVariable(variable, context)
-			|| hasBooleanPrefix(variable.name, prefixes)
+			hasBooleanPrefix(variable.name, prefixes)
+			|| isIgnoredName(variable.name, ignore)
+			|| !isBooleanVariable(variable, context)
 		) {
 			return;
 		}
@@ -423,8 +456,9 @@ const create = context => {
 
 		if (
 			!name
-			|| !isBooleanProperty(node, context)
 			|| hasBooleanPrefix(name, prefixes)
+			|| isIgnoredName(name, ignore)
+			|| !isBooleanProperty(node, context)
 		) {
 			return;
 		}
@@ -482,10 +516,15 @@ const config = {
 							pattern: '^[a-z][a-zA-Z0-9]*$',
 						},
 					},
+					ignore: {
+						type: 'array',
+						uniqueItems: true,
+						description: 'Patterns to ignore.',
+					},
 				},
 			},
 		],
-		defaultOptions: [{}],
+		defaultOptions: [{ignore: []}],
 		messages,
 	},
 };

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,