eslint-plugin-unicorn 68.0.0 → 69.0.0

package/rules/no-chained-comparison.js

@@ -10,7 +10,7 @@ const messages = {
 
 const orderingOperators = new Set(['<', '>', '<=', '>=']);
 const equalityOperators = new Set(['===', '!==', '==', '!=']);
-const comparisonOperators = new Set([...orderingOperators, ...equalityOperators]);
+const comparisonOperators = orderingOperators.union(equalityOperators);
 
 const isComparison = node => node.type === 'BinaryExpression' && comparisonOperators.has(node.operator);
 const isBooleanLiteral = node => node.type === 'Literal' && typeof node.value === 'boolean';

package/rules/no-computed-property-existence-check.js

@@ -1,6 +1,7 @@
 import {
 	getParenthesizedText,
 	hasOptionalChainElement,
+	isBoolean,
 	isBooleanExpression,
 	isControlFlowTest,
 	wouldRemoveComments,
@@ -120,6 +121,11 @@ const create = context => {
 			return;
 		}
 
+		// A property whose value type is a known boolean is a value read, not an existence check (and `no-unnecessary-boolean-comparison` may rewrite a comparison into this form).
+		if (isBoolean(node, context)) {
+			return;
+		}
+
 		return {
 			node,
 			messageId: MESSAGE_ID,

package/rules/no-incorrect-template-string-interpolation.js

@@ -20,6 +20,45 @@ const isBindingDeclaration = (raw, index) => {
 	return /^\s*(?:import|export|const|let|var)\b[^;={}]*$/.test(raw.slice(lineStart, index));
 };
 
+// `{type}` and `$expr}` inside an embedded block comment (e.g. JSDoc `@param {string}`) are not template interpolation mistakes (common in code-generation templates). Only closed `/* … */` comments count, so a stray `/*` inside a string doesn't suppress a genuine match.
+const getBlockCommentRanges = raw => raw.matchAll(/\/\*[\s\S]*?\*\//g)
+	.map(match => [match.index, match.index + match[0].length])
+	.toArray();
+
+const isInsideRanges = (ranges, index) => ranges.some(([start, end]) => index >= start && index < end);
+
+const getTemplateElementRawRange = (node, sourceCode) => {
+	const [start, end] = sourceCode.getRange(node);
+
+	return [
+		start + 1,
+		end - (node.tail ? 1 : 2),
+	];
+};
+
+const getTemplateRawWithExpressionsMasked = (node, sourceCode) => {
+	const [templateStart, templateEnd] = sourceCode.getRange(node);
+	const rawStart = templateStart + 1;
+	let raw = sourceCode.text.slice(rawStart, templateEnd - 1);
+
+	for (const [index, quasi] of node.quasis.entries()) {
+		const nextQuasi = node.quasis[index + 1];
+
+		if (!nextQuasi) {
+			break;
+		}
+
+		const [, quasiRawEnd] = getTemplateElementRawRange(quasi, sourceCode);
+		const [nextQuasiRawStart] = getTemplateElementRawRange(nextQuasi, sourceCode);
+		const maskStart = quasiRawEnd - rawStart;
+		const maskEnd = nextQuasiRawStart - rawStart;
+
+		raw = raw.slice(0, maskStart) + ' '.repeat(maskEnd - maskStart) + raw.slice(maskEnd);
+	}
+
+	return raw;
+};
+
 const getMissingDollarReplacements = raw => raw.matchAll(missingDollar)
 	.filter(match => !isBindingDeclaration(raw, match.index))
 	.map(match => ({
@@ -37,49 +76,62 @@ const getMissingOpeningBraceReplacements = raw => raw.matchAll(missingOpeningBra
 	}))
 	.toArray();
 
-const getReplacements = raw => {
+const getReplacements = (raw, blockCommentRanges, rawOffset) => {
 	const replacements = [
 		...getMissingDollarReplacements(raw),
 		...getMissingOpeningBraceReplacements(raw),
 	];
 
-	return replacements.toSorted((replacement, nextReplacement) => replacement.index - nextReplacement.index);
+	if (replacements.length === 0) {
+		return replacements;
+	}
+
+	return replacements
+		.filter(replacement => !isInsideRanges(blockCommentRanges, rawOffset + replacement.index))
+		.toSorted((replacement, nextReplacement) => replacement.index - nextReplacement.index);
 };
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
-	context.on('TemplateElement', function * (node) {
-		if (isTaggedTemplateLiteral(node.parent)) {
+	context.on('TemplateLiteral', function * (node) {
+		if (isTaggedTemplateLiteral(node)) {
 			return;
 		}
 
-		const rawStart = context.sourceCode.getRange(node)[0] + 1;
-
-		for (const {index, incorrect, correct} of getReplacements(node.value.raw)) {
-			const start = rawStart + index;
-			const end = start + incorrect.length;
-
-			yield {
-				node,
-				loc: {
-					start: context.sourceCode.getLocFromIndex(start),
-					end: context.sourceCode.getLocFromIndex(end),
-				},
-				messageId: MESSAGE_ID,
-				data: {
-					correct,
-				},
-				suggest: [
-					{
-						messageId: MESSAGE_ID_SUGGESTION,
-						data: {
-							incorrect,
-							correct,
-						},
-						fix: fixer => fixer.replaceTextRange([start, end], correct),
+		const templateRawStart = context.sourceCode.getRange(node)[0] + 1;
+		const blockCommentRanges = getBlockCommentRanges(getTemplateRawWithExpressionsMasked(node, context.sourceCode));
+
+		for (const quasi of node.quasis) {
+			const [rawStart, rawEnd] = getTemplateElementRawRange(quasi, context.sourceCode);
+			const raw = context.sourceCode.text.slice(rawStart, rawEnd);
+			const rawOffset = rawStart - templateRawStart;
+
+			for (const {index, incorrect, correct} of getReplacements(raw, blockCommentRanges, rawOffset)) {
+				const start = rawStart + index;
+				const end = start + incorrect.length;
+
+				yield {
+					node: quasi,
+					loc: {
+						start: context.sourceCode.getLocFromIndex(start),
+						end: context.sourceCode.getLocFromIndex(end),
 					},
-				],
-			};
+					messageId: MESSAGE_ID,
+					data: {
+						correct,
+					},
+					suggest: [
+						{
+							messageId: MESSAGE_ID_SUGGESTION,
+							data: {
+								incorrect,
+								correct,
+							},
+							fix: fixer => fixer.replaceTextRange([start, end], correct),
+						},
+					],
+				};
+			}
 		}
 	});
 };

package/rules/no-instanceof-builtins.js

@@ -3,6 +3,7 @@ import {
 	getParenthesizedRange,
 	getTokenStore,
 	isParenthesized,
+	isGlobalIdentifier,
 	shouldAddParenthesesToUnaryExpressionArgument,
 } from './utils/index.js';
 import {replaceNodeOrTokenAndSpacesBefore, fixSpaceAroundKeyword} from './fix/index.js';
@@ -26,6 +27,13 @@ const primitiveWrappers = new Set([
 	'Symbol',
 ]);
 
+const globalObjectNames = new Set([
+	'global',
+	'globalThis',
+	'self',
+	'window',
+]);
+
 const strictStrategyConstructors = [
 	// Error types
 	...builtinErrors,
@@ -73,7 +81,7 @@ const replaceWithFunctionCall = (node, context, functionName) => function * (fix
 	yield replaceNodeOrTokenAndSpacesBefore(right, '', fixer, context, tokenStore);
 };
 
-const replaceWithTypeOfExpression = (node, context) => function * (fixer) {
+const replaceWithTypeOfExpression = (node, context, constructorName) => function * (fixer) {
 	const {left, right} = node;
 	const tokenStore = getTokenStore(context, node);
 	const instanceofToken = tokenStore.getTokenAfter(left, isInstanceofToken);
@@ -105,9 +113,35 @@ const replaceWithTypeOfExpression = (node, context) => function * (fixer) {
 
 	const rightRange = getParenthesizedRange(right, {sourceCode: tokenStore});
 
-	yield fixer.replaceTextRange(rightRange, safeQuote + sourceCode.getText(right).toLowerCase() + safeQuote);
+	yield fixer.replaceTextRange(rightRange, safeQuote + constructorName.toLowerCase() + safeQuote);
 };
 
+function getConstructor(node, context) {
+	if (node.type === 'Identifier') {
+		return {
+			name: node.name,
+			referenceText: node.name,
+		};
+	}
+
+	if (
+		node.type === 'MemberExpression'
+		&& !node.computed
+		&& node.property.type === 'Identifier'
+		&& node.object.type === 'Identifier'
+		&& globalObjectNames.has(node.object.name)
+		&& isGlobalIdentifier(node.object, context)
+	) {
+		return {
+			name: node.property.name,
+			referenceText: context.sourceCode.getText(node),
+		};
+	}
+}
+
+const hasCommentsInside = (node, context) =>
+	context.sourceCode.getCommentsInside(node).length > 0;
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const {
@@ -124,11 +158,16 @@ const create = context => {
 	context.on('BinaryExpression', /** @param {import('estree').BinaryExpression} node */ node => {
 		const {right, operator} = node;
 
-		if ((operator !== 'instanceof') || (right.type !== 'Identifier') || exclude.includes(right.name)) {
+		if (operator !== 'instanceof') {
+			return;
+		}
+
+		const constructor = getConstructor(right, context);
+		if (!constructor || exclude.includes(constructor.name)) {
 			return;
 		}
 
-		const constructorName = right.name;
+		const {name: constructorName, referenceText} = constructor;
 
 		/** @type {import('eslint').Rule.ReportDescriptor} */
 		const problem = {
@@ -140,24 +179,31 @@ const create = context => {
 			constructorName === 'Array'
 			|| (constructorName === 'Error' && useErrorIsError)
 		) {
-			const functionName = constructorName === 'Array' ? 'Array.isArray' : 'Error.isError';
+			const methodName = constructorName === 'Array' ? 'isArray' : 'isError';
+			const functionName = `${referenceText}.${methodName}`;
 			problem.fix = replaceWithFunctionCall(node, context, functionName);
 			return problem;
 		}
 
 		if (constructorName === 'Function') {
-			problem.fix = replaceWithTypeOfExpression(node, context);
+			if (!hasCommentsInside(right, context)) {
+				problem.fix = replaceWithTypeOfExpression(node, context, constructorName);
+			}
+
 			return problem;
 		}
 
 		if (primitiveWrappers.has(constructorName)) {
-			problem.suggest = [
-				{
-					messageId: MESSAGE_ID_SWITCH_TO_TYPE_OF,
-					data: {type: constructorName.toLowerCase()},
-					fix: replaceWithTypeOfExpression(node, context),
-				},
-			];
+			if (!hasCommentsInside(right, context)) {
+				problem.suggest = [
+					{
+						messageId: MESSAGE_ID_SWITCH_TO_TYPE_OF,
+						data: {type: constructorName.toLowerCase()},
+						fix: replaceWithTypeOfExpression(node, context, constructorName),
+					},
+				];
+			}
+
 			return problem;
 		}
 

package/rules/no-invalid-well-known-symbol-methods.js

@@ -0,0 +1,205 @@
+import {isPromiseType} from './utils/index.js';
+
+const MESSAGE_ID_ASYNC_DISPOSE = 'no-invalid-well-known-symbol-methods/async-dispose';
+const MESSAGE_ID_DISPOSE_GENERATOR = 'no-invalid-well-known-symbol-methods/dispose-generator';
+const MESSAGE_ID_SYNC_ITERATOR = 'no-invalid-well-known-symbol-methods/sync-iterator';
+const MESSAGE_ID_ASYNC_ITERATOR = 'no-invalid-well-known-symbol-methods/async-iterator';
+const MESSAGE_ID_SUGGESTION = 'no-invalid-well-known-symbol-methods/suggestion';
+
+const messages = {
+	[MESSAGE_ID_ASYNC_DISPOSE]: '`Symbol.dispose` must not return a Promise. Use `Symbol.asyncDispose` instead.',
+	[MESSAGE_ID_DISPOSE_GENERATOR]: '`Symbol.dispose` must not be a generator. Use a normal method for synchronous disposal or `Symbol.asyncDispose` for asynchronous disposal.',
+	[MESSAGE_ID_SYNC_ITERATOR]: '`Symbol.iterator` must return a sync iterator. Use `Symbol.asyncIterator` for async iterators.',
+	[MESSAGE_ID_ASYNC_ITERATOR]: '`Symbol.asyncIterator` must return an async iterator directly. Use an async generator or return the iterator synchronously.',
+	[MESSAGE_ID_SUGGESTION]: 'Use `Symbol.{{replacement}}` instead.',
+};
+
+const promiseTypeNames = new Set(['Promise', 'PromiseLike']);
+const checkedSymbolNames = new Set(['dispose', 'iterator', 'asyncIterator']);
+
+function getWellKnownSymbolName(member) {
+	if (
+		!member.computed
+		|| member.key.type !== 'MemberExpression'
+		|| member.key.computed
+		|| member.key.object.type !== 'Identifier'
+		|| member.key.object.name !== 'Symbol'
+		|| member.key.property.type !== 'Identifier'
+	) {
+		return;
+	}
+
+	return member.key.property.name;
+}
+
+function getFunctionNode(member) {
+	if (member.kind === 'get' || member.kind === 'set') {
+		return;
+	}
+
+	if (
+		member.type === 'MethodDefinition'
+		|| member.type === 'PropertyDefinition'
+	) {
+		return member.value;
+	}
+
+	if (member.type === 'Property') {
+		return member.value;
+	}
+}
+
+function isFunctionNode(node) {
+	return node?.type === 'FunctionExpression' || node?.type === 'ArrowFunctionExpression';
+}
+
+function isPromiseTypeReference(node) {
+	return (
+		node.type === 'TSTypeReference'
+		&& node.typeName.type === 'Identifier'
+		&& promiseTypeNames.has(node.typeName.name)
+	);
+}
+
+function hasPromiseReturnTypeAnnotation(functionNode) {
+	const typeNode = functionNode.returnType?.typeAnnotation;
+	if (!typeNode) {
+		return false;
+	}
+
+	if (typeNode.type === 'TSTypeReference') {
+		return isPromiseTypeReference(typeNode);
+	}
+
+	if (typeNode.type === 'TSUnionType') {
+		return typeNode.types.some(typeNode => isPromiseTypeReference(typeNode));
+	}
+
+	return false;
+}
+
+function hasPromiseReturnTypeInformation(functionNode, context) {
+	const {parserServices} = context.sourceCode;
+	if (!parserServices?.program) {
+		return false;
+	}
+
+	try {
+		const checker = parserServices.program.getTypeChecker();
+		const typeScriptNode = parserServices.esTreeNodeToTSNodeMap.get(functionNode);
+		const signature = checker.getSignatureFromDeclaration(typeScriptNode);
+		if (signature) {
+			return isPromiseType(checker.getReturnTypeOfSignature(signature), checker) === true;
+		}
+
+		const type = parserServices.getTypeAtLocation(functionNode);
+		return type.getCallSignatures().some(signature =>
+			isPromiseType(checker.getReturnTypeOfSignature(signature), checker) === true,
+		);
+	} catch {
+		return false;
+	}
+}
+
+const hasPromiseReturnType = (functionNode, context) =>
+	hasPromiseReturnTypeAnnotation(functionNode)
+	|| hasPromiseReturnTypeInformation(functionNode, context);
+
+function getReplacementSuggestion(member, replacement) {
+	return {
+		messageId: MESSAGE_ID_SUGGESTION,
+		data: {replacement},
+		fix: fixer => fixer.replaceText(member.key.property, replacement),
+	};
+}
+
+function getProblem(member, context) {
+	const symbolName = getWellKnownSymbolName(member);
+	if (!checkedSymbolNames.has(symbolName)) {
+		return;
+	}
+
+	const functionNode = getFunctionNode(member);
+	if (!isFunctionNode(functionNode)) {
+		return;
+	}
+
+	if (
+		symbolName === 'dispose'
+		&& functionNode.generator
+	) {
+		return {
+			node: member.key,
+			messageId: MESSAGE_ID_DISPOSE_GENERATOR,
+		};
+	}
+
+	const returnsPromise = !functionNode.async && hasPromiseReturnType(functionNode, context);
+
+	if (
+		symbolName === 'dispose'
+		&& (functionNode.async || returnsPromise)
+	) {
+		return {
+			node: member.key,
+			messageId: MESSAGE_ID_ASYNC_DISPOSE,
+			fix: fixer => fixer.replaceText(member.key.property, 'asyncDispose'),
+		};
+	}
+
+	if (
+		symbolName === 'iterator'
+		&& (functionNode.async || returnsPromise)
+	) {
+		const problem = {
+			node: member.key,
+			messageId: MESSAGE_ID_SYNC_ITERATOR,
+		};
+
+		if (functionNode.generator) {
+			problem.suggest = [
+				getReplacementSuggestion(member, 'asyncIterator'),
+			];
+		}
+
+		return problem;
+	}
+
+	if (
+		symbolName === 'asyncIterator'
+		&& !functionNode.generator
+		&& (functionNode.async || returnsPromise)
+	) {
+		return {
+			node: member.key,
+			messageId: MESSAGE_ID_ASYNC_ITERATOR,
+		};
+	}
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('MethodDefinition', node => getProblem(node, context));
+	context.on('Property', node => getProblem(node, context));
+	context.on('PropertyDefinition', node => getProblem(node, context));
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow invalid implementations of well-known symbol methods.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-late-current-target-access.js

@@ -1,84 +1,22 @@
 import {findVariable} from '@eslint-community/eslint-utils';
-import {isMemberExpression, isFunction} from './ast/index.js';
-import {containsSuspensionPoint} from './utils/index.js';
+import {isMemberExpression} from './ast/index.js';
+import {
+	createLateEventHandlerTracker,
+	eventParameterNamePattern,
+	getEnclosingFunction,
+} from './shared/late-event-handler.js';
 
 const MESSAGE_ID_AFTER_SUSPENSION = 'after-suspension';
 const MESSAGE_ID_IN_NESTED_FUNCTION = 'in-nested-function';
-const eventParameterNamePattern = /^(?:e|event|evt|[a-z][\dA-Za-z]*Event)$/u;
 const messages = {
 	[MESSAGE_ID_AFTER_SUSPENSION]: '`{{name}}.currentTarget` is `null` after the handler suspends. It is only set during synchronous event dispatch; save it to a variable beforehand.',
 	[MESSAGE_ID_IN_NESTED_FUNCTION]: '`{{name}}.currentTarget` is `null` inside this nested function. It is only set during synchronous event dispatch; save it to a variable in the outer function.',
 };
 
-const getEnclosingFunction = node => {
-	for (let current = node.parent; current; current = current.parent) {
-		if (isFunction(current)) {
-			return current;
-		}
-	}
-};
-
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;
-	// Functions that have passed a suspension point (`await`/`for await…of`/`yield`) at the current point of the traversal.
-	const suspendedFunctions = new Set();
-
-	// ESLint traverses in source order and fires `onExit` only after the whole subtree of the
-	// suspension point is visited, so by the time a later access is reached it has “completed”.
-	const markSuspended = node => {
-		const functionNode = getEnclosingFunction(node);
-		if (functionNode) {
-			suspendedFunctions.add(functionNode);
-		}
-	};
-
-	const isRepeatedLoopPart = (loop, child) => {
-		switch (loop.type) {
-			case 'ForStatement': {
-				return [
-					loop.test,
-					loop.update,
-					loop.body,
-				].includes(child);
-			}
-
-			case 'ForInStatement':
-			case 'ForOfStatement': {
-				return child !== loop.right;
-			}
-
-			case 'DoWhileStatement':
-			case 'WhileStatement': {
-				return true;
-			}
-
-			default: {
-				return false;
-			}
-		}
-	};
-
-	const isInsideSuspendingLoop = (node, functionNode) => {
-		for (let child = node, current = node.parent; current && current !== functionNode; child = current, current = current.parent) {
-			if (
-				isRepeatedLoopPart(current, child)
-				&& containsSuspensionPoint(current, sourceCode.visitorKeys)
-			) {
-				return true;
-			}
-		}
-
-		return false;
-	};
-
-	context.onExit('AwaitExpression', markSuspended);
-	context.onExit('YieldExpression', markSuspended);
-	context.onExit('ForOfStatement', node => {
-		if (node.await) {
-			markSuspended(node);
-		}
-	});
+	const lateEventHandlerTracker = createLateEventHandlerTracker(context);
 
 	context.on('MemberExpression', node => {
 		if (
@@ -104,8 +42,8 @@ const create = context => {
 
 		if (
 			!isInNestedFunction
-			&& !suspendedFunctions.has(handlerFunction)
-			&& !isInsideSuspendingLoop(node, handlerFunction)
+			&& !lateEventHandlerTracker.isFunctionSuspended(handlerFunction)
+			&& !lateEventHandlerTracker.isInsideSuspendingLoop(node, handlerFunction)
 		) {
 			return;
 		}