eslint-plugin-unicorn 68.0.0 → 69.0.0

package/rules/no-late-event-control.js

@@ -0,0 +1,127 @@
+import {findVariable} from '@eslint-community/eslint-utils';
+import {isMethodCall} from './ast/index.js';
+import {
+	createLateEventHandlerTracker,
+	eventParameterNamePattern,
+	getEnclosingFunction,
+} from './shared/late-event-handler.js';
+import {
+	isEvent,
+	isKnownNonEvent,
+	unwrapTypeScriptExpression,
+} from './utils/index.js';
+
+const MESSAGE_ID_AFTER_SUSPENSION = 'after-suspension';
+const MESSAGE_ID_IN_GENERATOR = 'in-generator';
+const MESSAGE_ID_IN_NESTED_FUNCTION = 'in-nested-function';
+const eventControlMethodNames = [
+	'preventDefault',
+	'stopImmediatePropagation',
+	'stopPropagation',
+];
+const messages = {
+	[MESSAGE_ID_AFTER_SUSPENSION]: '`{{name}}.{{method}}()` has no effect after the handler suspends. Call it before `await` or `yield` while the event is still being dispatched.',
+	[MESSAGE_ID_IN_GENERATOR]: '`{{name}}.{{method}}()` is not called during event dispatch inside a generator function. Use a normal function handler instead.',
+	[MESSAGE_ID_IN_NESTED_FUNCTION]: '`{{name}}.{{method}}()` may run after synchronous event dispatch has finished. Call it in the outer handler before deferring work.',
+};
+
+const getEventControlCall = node => {
+	if (!isMethodCall(node, {
+		methods: eventControlMethodNames,
+		computed: false,
+	})) {
+		return;
+	}
+
+	const {callee} = node;
+	const event = unwrapTypeScriptExpression(callee.object);
+	if (event.type !== 'Identifier') {
+		return;
+	}
+
+	return {
+		event,
+		method: callee.property.name,
+	};
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const lateEventHandlerTracker = createLateEventHandlerTracker(context);
+
+	const isEventParameter = node => {
+		if (isKnownNonEvent(node, context)) {
+			return false;
+		}
+
+		return eventParameterNamePattern.test(node.name)
+			|| isEvent(node, context);
+	};
+
+	context.onExit('CallExpression', node => {
+		const eventControlCall = getEventControlCall(node);
+		if (!eventControlCall) {
+			return;
+		}
+
+		const {event, method} = eventControlCall;
+		const variable = findVariable(sourceCode.getScope(event), event);
+		const definition = variable?.defs.find(({type}) => type === 'Parameter');
+		if (!definition) {
+			return;
+		}
+
+		// For a parameter definition, `definition.node` is the function that declares it.
+		const handlerFunction = definition.node;
+		if (!isEventParameter(definition.name)) {
+			return;
+		}
+
+		const isInNestedFunction = getEnclosingFunction(node) !== handlerFunction;
+		const isInGeneratorHandler = handlerFunction.generator;
+		if (
+			!isInNestedFunction
+			&& !isInGeneratorHandler
+			&& !lateEventHandlerTracker.isFunctionSuspended(handlerFunction)
+			&& !lateEventHandlerTracker.isInsideSuspendingLoop(node, handlerFunction)
+		) {
+			return;
+		}
+
+		let messageId = MESSAGE_ID_AFTER_SUSPENSION;
+		if (isInNestedFunction) {
+			messageId = MESSAGE_ID_IN_NESTED_FUNCTION;
+		} else if (isInGeneratorHandler) {
+			messageId = MESSAGE_ID_IN_GENERATOR;
+		}
+
+		return {
+			node,
+			messageId,
+			data: {
+				name: event.name,
+				method,
+			},
+		};
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow event-control method calls after the synchronous event dispatch has finished.',
+			recommended: true,
+		},
+		schema: [],
+		messages,
+		languages: [
+			'js/js',
+		],
+	},
+};
+
+export default config;

package/rules/no-nonstandard-builtin-properties.js

@@ -284,6 +284,8 @@ const errorPrototype = createPropertyInfo({
 	properties: [
 		'message',
 		'name',
+		// Deliberate exception to the published-spec-only boundary below: `stack` is a stage-3 proposal (https://github.com/tc39/proposal-error-stack-accessor) that is universally implemented across engines.
+		'stack',
 	],
 	methods: [
 		'toString',

package/rules/no-object-methods-with-collections.js

@@ -1,30 +1,13 @@
-import {findVariable} from '@eslint-community/eslint-utils';
-import {isNewExpression} from './ast/index.js';
 import {
+	getBuiltinCollectionType,
+	isGlobalIdentifier,
 	getParenthesizedText,
-	getTypeSymbol,
-	isUnknownType,
 	shouldAddParenthesesToMemberExpressionObject,
 } from './utils/index.js';
 
 const MESSAGE_ID_ERROR = 'no-object-methods-with-collections/error';
 const MESSAGE_ID_SUGGESTION = 'no-object-methods-with-collections/suggestion';
 
-const mapTypes = new Set([
-	'Map',
-	'ReadonlyMap',
-]);
-
-const setTypes = new Set([
-	'Set',
-	'ReadonlySet',
-]);
-
-const collectionTypes = new Set([
-	...mapTypes,
-	...setTypes,
-]);
-
 const objectMethods = new Set([
 	'entries',
 	'keys',
@@ -36,274 +19,6 @@ const messages = {
 	[MESSAGE_ID_SUGGESTION]: 'Use `Array.from({{replacement}})`.',
 };
 
-const getTypeSet = type => new Set([type]);
-
-const getTypeFromTypeReferenceName = name => collectionTypes.has(name) ? name : undefined;
-
-const typeDeclarationNodeTypes = new Set([
-	'ClassDeclaration',
-	'TSEnumDeclaration',
-	'TSInterfaceDeclaration',
-	'TSTypeAliasDeclaration',
-]);
-
-const getTypeDeclarationName = node => {
-	if (!node || !typeDeclarationNodeTypes.has(node.type)) {
-		return;
-	}
-
-	return node.id?.name;
-};
-
-const getProgramNode = node => {
-	while (node.parent) {
-		node = node.parent;
-	}
-
-	return node.type === 'Program' ? node : undefined;
-};
-
-const hasUserDefinedTypeName = (name, node) => {
-	const program = getProgramNode(node);
-	if (!program) {
-		return false;
-	}
-
-	for (const node of program.body) {
-		if (node.type === 'ImportDeclaration') {
-			if (node.specifiers.some(specifier => specifier.local.name === name)) {
-				return true;
-			}
-
-			continue;
-		}
-
-		if (
-			node.type === 'ExportNamedDeclaration'
-			|| node.type === 'ExportDefaultDeclaration'
-		) {
-			if (getTypeDeclarationName(node.declaration) === name) {
-				return true;
-			}
-
-			continue;
-		}
-
-		if (getTypeDeclarationName(node) === name) {
-			return true;
-		}
-	}
-
-	return false;
-};
-
-const mergeTypeSets = typeSets => {
-	const types = new Set();
-
-	for (const typeSet of typeSets) {
-		if (!typeSet) {
-			return;
-		}
-
-		for (const type of typeSet) {
-			types.add(type);
-		}
-	}
-
-	return types;
-};
-
-const isUnshadowedGlobalIdentifier = (node, context) => {
-	const variable = findVariable(context.sourceCode.getScope(node), node);
-	return !variable || (variable.scope.type === 'global' && variable.defs.length === 0);
-};
-
-const isDefaultLibraryOnlySymbol = (symbol, program) =>
-	symbol?.declarations?.length > 0
-	&& symbol.declarations.every(declaration => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
-
-const getTypesFromType = (type, program) => {
-	if (isUnknownType(type)) {
-		return;
-	}
-
-	if (type.isUnion()) {
-		return mergeTypeSets(type.types.map(type => getTypesFromType(type, program)));
-	}
-
-	const symbol = getTypeSymbol(type);
-	if (!isDefaultLibraryOnlySymbol(symbol, program)) {
-		return;
-	}
-
-	const typeName = symbol.getName();
-	const collectionType = typeName && getTypeFromTypeReferenceName(typeName);
-	return collectionType && getTypeSet(collectionType);
-};
-
-const hasUserDefinedCollectionType = (types, node) => {
-	for (const type of types) {
-		if (hasUserDefinedTypeName(type, node)) {
-			return true;
-		}
-	}
-
-	return false;
-};
-
-const getTypesFromTypeInformation = (node, context) => {
-	const {parserServices} = context.sourceCode;
-	if (!parserServices?.program) {
-		return;
-	}
-
-	try {
-		const {program} = parserServices;
-		const types = getTypesFromType(
-			parserServices.getTypeAtLocation(node),
-			program,
-		);
-
-		if (types && !hasUserDefinedCollectionType(types, node)) {
-			return types;
-		}
-	} catch {
-		// TypeScript can throw while resolving incomplete projects; keep this fallback best-effort.
-	}
-};
-
-const getTypesFromTypeAnnotation = (node, context) => {
-	switch (node?.type) {
-		case 'TSTypeAnnotation':
-		case 'TSParenthesizedType': {
-			return getTypesFromTypeAnnotation(node.typeAnnotation, context);
-		}
-
-		case 'TSTypeOperator': {
-			return node.operator === 'readonly'
-				? getTypesFromTypeAnnotation(node.typeAnnotation, context)
-				: undefined;
-		}
-
-		case 'TSTypeReference': {
-			if (node.typeName.type !== 'Identifier') {
-				return;
-			}
-
-			if (hasUserDefinedTypeName(node.typeName.name, node)) {
-				return;
-			}
-
-			const type = getTypeFromTypeReferenceName(node.typeName.name);
-			return type && getTypeSet(type);
-		}
-
-		case 'TSUnionType': {
-			return mergeTypeSets(node.types.map(type => getTypesFromTypeAnnotation(type, context)));
-		}
-
-		default: {
-			break;
-		}
-	}
-};
-
-const getTypesFromVariable = (node, context, visitedVariables) => {
-	const variable = findVariable(context.sourceCode.getScope(node), node);
-	if (
-		!variable
-		|| visitedVariables.has(variable)
-		|| variable.defs.length !== 1
-	) {
-		return;
-	}
-
-	visitedVariables.add(variable);
-
-	const [definition] = variable.defs;
-	const annotationTypes = getTypesFromTypeAnnotation(definition.name?.typeAnnotation, context);
-	if (annotationTypes) {
-		return annotationTypes;
-	}
-
-	if (
-		definition.type !== 'Variable'
-		|| definition.parent.kind !== 'const'
-		|| !definition.node.init
-	) {
-		return;
-	}
-
-	return getTypes(definition.node.init, context, visitedVariables);
-};
-
-const getTypesFromSyntax = (node, context, visitedVariables) => {
-	if (
-		isNewExpression(node, {names: ['Map', 'Set']})
-		&& isUnshadowedGlobalIdentifier(node.callee, context)
-	) {
-		return getTypeSet(node.callee.name);
-	}
-
-	switch (node.type) {
-		case 'Identifier': {
-			return getTypesFromVariable(node, context, visitedVariables);
-		}
-
-		case 'TSAsExpression':
-		case 'TSSatisfiesExpression':
-		case 'TSTypeAssertion': {
-			return getTypesFromTypeAnnotation(node.typeAnnotation, context) ?? getTypes(node.expression, context, visitedVariables);
-		}
-
-		case 'TSNonNullExpression': {
-			return getTypes(node.expression, context, visitedVariables);
-		}
-
-		case 'ParenthesizedExpression': {
-			return getTypes(node.expression, context, visitedVariables);
-		}
-
-		default: {
-			break;
-		}
-	}
-};
-
-const getTypes = (node, context, visitedVariables = new Set()) =>
-	getTypesFromTypeInformation(node, context)
-	?? getTypesFromSyntax(node, context, visitedVariables);
-
-const getCollectionType = (node, context) => {
-	const types = getTypes(node, context);
-	if (!types?.size) {
-		return;
-	}
-
-	let hasMapType = false;
-	let hasSetType = false;
-
-	for (const type of types) {
-		if (mapTypes.has(type)) {
-			hasMapType = true;
-			continue;
-		}
-
-		if (setTypes.has(type)) {
-			hasSetType = true;
-			continue;
-		}
-
-		return;
-	}
-
-	if (hasMapType && hasSetType) {
-		return;
-	}
-
-	return hasMapType ? 'Map' : 'Set';
-};
-
 const getMemberObjectText = (node, context) => {
 	const text = getParenthesizedText(node, context);
 	return shouldAddParenthesesToMemberExpressionObject(node, context) ? `(${text})` : text;
@@ -319,7 +34,7 @@ const getProblem = (node, context) => {
 		|| callee.computed
 		|| callee.object.type !== 'Identifier'
 		|| callee.object.name !== 'Object'
-		|| !isUnshadowedGlobalIdentifier(callee.object, context)
+		|| !isGlobalIdentifier(callee.object, context)
 		|| callee.property.type !== 'Identifier'
 		|| !objectMethods.has(callee.property.name)
 	) {
@@ -327,7 +42,7 @@ const getProblem = (node, context) => {
 	}
 
 	const [argument] = node.arguments;
-	const type = getCollectionType(argument, context);
+	const type = getBuiltinCollectionType(argument, context);
 	if (!type) {
 		return;
 	}

package/rules/no-return-array-push.js

@@ -1,5 +1,5 @@
 import {isMethodCall} from './ast/index.js';
-import {needsSemicolon} from './utils/index.js';
+import {isKnownNonArray, needsSemicolon} from './utils/index.js';
 
 const MESSAGE_ID_ERROR = 'no-return-array-push/error';
 const MESSAGE_ID_SUGGESTION = 'no-return-array-push/suggestion';
@@ -77,9 +77,22 @@ function getDirectReturnStatement(callExpression) {
 	}
 }
 
-function isBareExpressionStatement(expression) {
-	const node = getCallExpressionResultNode(expression);
-	return node.parent.type === 'ExpressionStatement';
+function isReturnValueDiscarded(callExpression) {
+	const node = getCallExpressionResultNode(callExpression);
+	const {parent} = node;
+	return (
+		parent.type === 'ExpressionStatement'
+		// The `void` operator explicitly discards the return value.
+		|| (parent.type === 'UnaryExpression' && parent.operator === 'void')
+	);
+}
+
+// Treat chained result member access as a pragmatic signal for custom APIs like router.push().catch(...).
+// Do not flag realistic code only to catch theoretical Number method chains from Array#push().
+function isResultMemberAccessed(callExpression) {
+	const node = getCallExpressionResultNode(callExpression);
+	const {parent} = node;
+	return parent.type === 'MemberExpression' && parent.object === node;
 }
 
 function getSuggestion(callExpression, returnStatement, method, context) {
@@ -121,7 +134,9 @@ const create = context => {
 
 		if (
 			(method === 'push' && isIgnoredCallee(callExpression.callee))
-			|| isBareExpressionStatement(callExpression)
+			|| isReturnValueDiscarded(callExpression)
+			|| isResultMemberAccessed(callExpression)
+			|| isKnownNonArray(callExpression.callee.object, context)
 		) {
 			return;
 		}

package/rules/no-top-level-side-effects.js

@@ -12,7 +12,14 @@ const exportDeclarationTypes = new Set([
 	'ExportNamedDeclaration',
 ]);
 
-const isExportDeclaration = node => exportDeclarationTypes.has(node.type);
+// Type-only exports (`export type`, `export interface`, `export declare`, `export {type Foo}`, …) are erased when TypeScript is compiled to JavaScript, so a file whose only exports are type-only has no runtime exports.
+const isTypeOnlyExport = node =>
+	node.exportKind === 'type'
+	|| node.declaration?.type === 'TSInterfaceDeclaration'
+	// `export {type Foo}` keeps `exportKind: 'value'` on the declaration, but every specifier is type-only, so it is fully erased. `export {}` (no specifiers) is a runtime module marker and is not type-only.
+	|| (node.specifiers?.length > 0 && node.specifiers.every(specifier => specifier.exportKind === 'type'));
+
+const isExportDeclaration = node => exportDeclarationTypes.has(node.type) && !isTypeOnlyExport(node);
 
 const isAllowedAssignment = node => unwrapTypeScriptExpression(node).type === 'AssignmentExpression';
 

package/rules/no-unnecessary-global-this.js

@@ -6,7 +6,13 @@ import {
 } from '@babel/helper-validator-identifier';
 import {findVariable} from '@eslint-community/eslint-utils';
 import {isStringLiteral} from './ast/index.js';
-import {hasOptionalChainElement, isGlobalIdentifier, isLeftHandSide} from './utils/index.js';
+import {
+	hasOptionalChainElement,
+	isGlobalIdentifier,
+	isLeftHandSide,
+	isControlFlowTest,
+	isBooleanExpression,
+} from './utils/index.js';
 
 const MESSAGE_ID = 'no-unnecessary-global-this';
 const messages = {
@@ -96,6 +102,34 @@ function isTaggedTemplateCallee(node) {
 		&& node.parent.tag === node;
 }
 
+const equalityOperators = new Set(['==', '!=', '===', '!==']);
+
+// `globalThis.foo === undefined`, `globalThis.foo != null`, … compare the global against `null`/`undefined` to detect its presence.
+function isNullishComparison(node) {
+	const {parent} = node;
+	if (
+		parent.type !== 'BinaryExpression'
+		|| !equalityOperators.has(parent.operator)
+	) {
+		return false;
+	}
+
+	const other = unwrapTypeScriptExpression(parent.left === node ? parent.right : parent.left);
+
+	return (other.type === 'Literal' && other.value === null)
+		|| (other.type === 'Identifier' && other.name === 'undefined');
+}
+
+// `globalThis.foo` in an existence check (`if (globalThis.foo)`, `globalThis.foo ?? x`, `!globalThis.foo`, `globalThis.foo === undefined`, …) safely yields `undefined` when the global is absent, whereas bare `foo` throws a `ReferenceError`. This is deliberate feature detection, so the `globalThis` receiver must be kept.
+function isExistenceCheck(node, context) {
+	node = getOuterTypeScriptExpression(node);
+
+	return node.parent.type === 'LogicalExpression'
+		|| isNullishComparison(node)
+		|| isControlFlowTest(node)
+		|| isBooleanExpression(node, context);
+}
+
 function isOptionalChainUsage(node) {
 	if (hasOptionalChainElement(node)) {
 		return true;
@@ -123,6 +157,7 @@ const create = context => {
 			|| !isGlobalIdentifier(object, context)
 			|| isWritableTarget(writableTarget)
 			|| isOptionalChainUsage(node)
+			|| isExistenceCheck(node, context)
 		) {
 			return;
 		}

package/rules/no-unreadable-object-destructuring.js

@@ -1,3 +1,4 @@
+import {getStaticValue} from '@eslint-community/eslint-utils';
 import {isTypeScriptExpressionWrapper} from './utils/index.js';
 
 const MESSAGE_ID_COMPUTED_KEY = 'computed-key';
@@ -70,6 +71,10 @@ function getObjectPatternDepth(node) {
 	return depth;
 }
 
+function isStaticComputedKey(node, scope) {
+	return getStaticValue(node, scope) !== null;
+}
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	context.on('Property', node => {
@@ -80,6 +85,16 @@ const create = context => {
 			return;
 		}
 
+		// A computed key is the only way to exclude a dynamic property from a rest element,
+		// so allow it when the same object pattern collects a rest. A static key is not
+		// dynamic, so it stays disallowed.
+		if (
+			!isStaticComputedKey(node.key, context.sourceCode.getScope(node.key))
+			&& node.parent.properties.some(property => property.type === 'RestElement')
+		) {
+			return;
+		}
+
 		return {
 			node,
 			messageId: MESSAGE_ID_COMPUTED_KEY,

package/rules/no-unsafe-string-replacement.js

@@ -5,6 +5,10 @@ import {
 	isStringLiteral,
 } from './ast/index.js';
 import {unwrapExpression} from './utils/comparison.js';
+import {
+	getConstVariableInitializer,
+	isKnownNonString,
+} from './utils/index.js';
 
 const MESSAGE_ID = 'no-unsafe-string-replacement';
 const messages = {
@@ -34,6 +38,25 @@ const isAllowedReplacement = (node, sourceCode) => {
 		|| isFunction(node);
 };
 
+const objectCoercionPropertyNames = new Set([
+	'__proto__',
+	'toString',
+	'valueOf',
+]);
+
+const isPlainObjectReplacement = (node, context) => {
+	node = unwrapExpression(node);
+	const replacement = unwrapExpression(getConstVariableInitializer(node, context) ?? node);
+
+	return replacement.type === 'ObjectExpression'
+		&& replacement.properties.every(property =>
+			property.type === 'Property'
+			&& !property.computed
+			&& !property.method
+			&& property.kind === 'init'
+			&& !objectCoercionPropertyNames.has(property.key.name ?? property.key.value));
+};
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	context.on('CallExpression', node => {
@@ -49,6 +72,14 @@ const create = context => {
 			return;
 		}
 
+		if (isPlainObjectReplacement(replacement, context)) {
+			return;
+		}
+
+		if (isKnownNonString(node.callee.object, context)) {
+			return;
+		}
+
 		return {
 			node: replacement,
 			messageId: MESSAGE_ID,

package/rules/no-unused-array-method-return.js

@@ -1,5 +1,5 @@
 import {findVariable, getPropertyName} from '@eslint-community/eslint-utils';
-import {isValueNotUsable} from './utils/index.js';
+import {isArray, isValueNotUsable} from './utils/index.js';
 
 const MESSAGE_ID = 'no-unused-array-method-return';
 const messages = {
@@ -38,6 +38,10 @@ const methods = new Set([
 	'with',
 ]);
 
+const methodsRequiringArrayReceiver = new Set([
+	'values',
+]);
+
 const pascalCaseNamePattern = /^\p{Uppercase_Letter}/v;
 const uncertainValue = Symbol('uncertainValue');
 const nonArrayFactoryFunctions = new Set([
@@ -238,6 +242,11 @@ const isObviouslyNonArrayReceiver = (node, context) => {
 		);
 };
 
+const shouldSkipReceiver = (node, method, context) =>
+	methodsRequiringArrayReceiver.has(method)
+		? !isArray(node, context)
+		: isObviouslyNonArrayReceiver(node, context);
+
 const getTrackedMethodName = (node, context) =>
 	node.callee.type === 'MemberExpression'
 		? getStaticPropertyName(node.callee, context)
@@ -294,7 +303,7 @@ const create = context => {
 		if (
 			!methods.has(method)
 			|| !isDiscardedExpression(node)
-			|| isObviouslyNonArrayReceiver(node.callee.object, context)
+			|| shouldSkipReceiver(node.callee.object, method, context)
 		) {
 			return;
 		}