eslint-plugin-unicorn 63.0.0 → 65.0.0

package/rules/consistent-destructuring.js

@@ -1,5 +1,6 @@
+import {findVariable} from '@eslint-community/eslint-utils';
 import {getAvailableVariableName, isLeftHandSide} from './utils/index.js';
-import {isCallOrNewExpression} from './ast/index.js';
+import {isCallOrNewExpression, isStringLiteral} from './ast/index.js';
 
 const MESSAGE_ID = 'consistentDestructuring';
 const MESSAGE_ID_SUGGEST = 'consistentDestructuringSuggest';
@@ -33,6 +34,200 @@ const isChildInParentScope = (child, parent) => {
 	return false;
 };
 
+const getRootIdentifier = expression => {
+	while (expression?.type === 'MemberExpression') {
+		expression = expression.object;
+	}
+
+	return expression?.type === 'Identifier' ? expression : undefined;
+};
+
+const hasRestElement = pattern => {
+	switch (pattern?.type) {
+		case 'RestElement': {
+			return true;
+		}
+
+		case 'AssignmentPattern': {
+			return hasRestElement(pattern.left);
+		}
+
+		case 'ObjectPattern': {
+			return pattern.properties.some(property =>
+				hasRestElement(property.type === 'Property' ? property.value : property));
+		}
+
+		case 'ArrayPattern': {
+			return pattern.elements.some(element =>
+				hasRestElement(element));
+		}
+
+		default: {
+			return false;
+		}
+	}
+};
+
+const isIdentifierProperty = property =>
+	property.type === 'Property'
+	&& property.key.type === 'Identifier';
+
+const hasNestedRestElement = pattern => {
+	switch (pattern?.type) {
+		case 'AssignmentPattern': {
+			return hasNestedRestElement(pattern.left);
+		}
+
+		case 'ObjectPattern': {
+			return pattern.properties.some(property => {
+				if (property.type === 'RestElement') {
+					return false;
+				}
+
+				return hasRestElement(property.value);
+			});
+		}
+
+		case 'ArrayPattern': {
+			return pattern.elements.some(element => {
+				if (!element || element.type === 'RestElement') {
+					return false;
+				}
+
+				return hasRestElement(element);
+			});
+		}
+
+		default: {
+			return false;
+		}
+	}
+};
+
+const isMemberDestructuredInNestedPatternWithRest = (objectPattern, memberName) =>
+	objectPattern.properties.some(property =>
+		isIdentifierProperty(property)
+		&& property.key.name === memberName
+		&& property.value.type !== 'Identifier'
+		&& hasNestedRestElement(property.value));
+
+const shouldIgnoreMemberExpression = node =>
+	node.computed
+	|| (
+		isCallOrNewExpression(node.parent)
+		&& node.parent.callee === node
+	)
+	|| isLeftHandSide(node);
+
+const isRootVariableReassigned = (declaration, memberExpressionNode, memberScope, sourceCode) => {
+	if (!declaration.rootVariable) {
+		return false;
+	}
+
+	const [, declarationEnd] = sourceCode.getRange(declaration.object);
+	const [memberStart] = sourceCode.getRange(memberExpressionNode);
+
+	return declaration.rootVariable.references.some(reference => {
+		if (!reference.isWrite()) {
+			return false;
+		}
+
+		const [referenceStart] = sourceCode.getRange(reference.identifier);
+		if (referenceStart < declarationEnd) {
+			return false;
+		}
+
+		// Be conservative: writes from other variable scopes may run before this read via calls/closures.
+		if (reference.from.variableScope !== memberScope.variableScope) {
+			return true;
+		}
+
+		return referenceStart <= memberStart;
+	});
+};
+
+const isMatchingInExpression = (node, memberExpression, sourceCode) => {
+	if (!(
+		node.type === 'BinaryExpression'
+		&& node.operator === 'in'
+		&& isStringLiteral(node.left)
+		&& memberExpression.property.type === 'Identifier'
+		&& node.left.value === memberExpression.property.name
+	)) {
+		return false;
+	}
+
+	return sourceCode.getText(node.right) === sourceCode.getText(memberExpression.object);
+};
+
+const hasMatchingInExpression = (node, memberExpression, sourceCode) => {
+	if (isMatchingInExpression(node, memberExpression, sourceCode)) {
+		return true;
+	}
+
+	if (
+		node.type !== 'LogicalExpression'
+		|| node.operator !== '&&'
+	) {
+		return false;
+	}
+
+	return hasMatchingInExpression(node.left, memberExpression, sourceCode)
+		|| hasMatchingInExpression(node.right, memberExpression, sourceCode);
+};
+
+const isInPositiveGuardBranch = (parent, child, memberExpression, sourceCode) => {
+	switch (parent.type) {
+		case 'ConditionalExpression': {
+			return parent.consequent === child
+				&& hasMatchingInExpression(parent.test, memberExpression, sourceCode);
+		}
+
+		case 'LogicalExpression': {
+			return parent.operator === '&&'
+				&& parent.right === child
+				&& hasMatchingInExpression(parent.left, memberExpression, sourceCode);
+		}
+
+		case 'IfStatement': {
+			return parent.consequent === child
+				&& hasMatchingInExpression(parent.test, memberExpression, sourceCode);
+		}
+
+		default: {
+			return false;
+		}
+	}
+};
+
+const isInTypeGuardBoundary = node =>
+	[
+		'AccessorProperty',
+		'FunctionDeclaration',
+		'MethodDefinition',
+		'PropertyDefinition',
+	].includes(node.type);
+
+const isInTypeGuardedBranch = (node, sourceCode) => {
+	let child = node;
+	let {parent} = node;
+
+	while (parent) {
+		if (isInTypeGuardBoundary(parent)) {
+			return false;
+		}
+
+		if (isInPositiveGuardBranch(parent, child, node, sourceCode)) {
+			return true;
+		}
+
+		child = parent;
+		parent = parent.parent;
+	}
+
+	return false;
+};
+
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
 	const {sourceCode} = context;
@@ -49,22 +244,18 @@ const create = context => {
 			return;
 		}
 
+		const rootIdentifier = getRootIdentifier(node.init);
 		declarations.set(sourceCode.getText(node.init), {
 			scope: sourceCode.getScope(node),
-			variables: sourceCode.getDeclaredVariables(node),
+			object: node.init,
+			rootIdentifierName: rootIdentifier?.name,
+			rootVariable: rootIdentifier && findVariable(sourceCode.getScope(node), rootIdentifier),
 			objectPattern: node.id,
 		});
 	});
 
 	context.on('MemberExpression', node => {
-		if (
-			node.computed
-			|| (
-				isCallOrNewExpression(node.parent)
-				&& node.parent.callee === node
-			)
-			|| isLeftHandSide(node)
-		) {
+		if (shouldIgnoreMemberExpression(node)) {
 			return;
 		}
 
@@ -74,32 +265,53 @@ const create = context => {
 			return;
 		}
 
-		const {scope, objectPattern} = declaration;
 		const memberScope = sourceCode.getScope(node);
+		const memberRootIdentifier = getRootIdentifier(node.object);
+		const memberRootVariable = memberRootIdentifier && findVariable(memberScope, memberRootIdentifier);
+		if (
+			declaration.rootIdentifierName
+			&& memberRootIdentifier?.name === declaration.rootIdentifierName
+			&& memberRootVariable !== declaration.rootVariable
+		) {
+			return;
+		}
+
+		if (isRootVariableReassigned(declaration, node, memberScope, sourceCode)) {
+			return;
+		}
+
+		const {scope, objectPattern} = declaration;
 
 		// Property is destructured outside the current scope
 		if (!isChildInParentScope(memberScope, scope)) {
 			return;
 		}
 
-		const destructurings = objectPattern.properties.filter(property =>
-			property.type === 'Property'
-			&& property.key.type === 'Identifier'
-			&& property.value.type === 'Identifier',
-		);
-		const lastProperty = objectPattern.properties.at(-1);
+		const member = sourceCode.getText(node.property);
+
+		if (isInTypeGuardedBranch(node, sourceCode)) {
+			return;
+		}
 
-		const hasRest = lastProperty && lastProperty.type === 'RestElement';
+		const memberDestructuredInNestedPattern = isMemberDestructuredInNestedPatternWithRest(objectPattern, member);
 
+		const destructuredProperties = objectPattern.properties.filter(property =>
+			isIdentifierProperty(property)
+			&& property.value.type === 'Identifier');
+
+		const lastProperty = objectPattern.properties.at(-1);
+		const hasRest = lastProperty?.type === 'RestElement';
 		const expression = sourceCode.getText(node);
-		const member = sourceCode.getText(node.property);
 
 		// Member might already be destructured
-		const destructuredMember = destructurings.find(property =>
-			property.key.name === member,
-		);
+		const destructuredMember = destructuredProperties.find(property =>
+			property.key.name === member);
 
 		if (!destructuredMember) {
+			if (memberDestructuredInNestedPattern) {
+				return;
+			}
+
 			// Don't destructure additional members when rest is used
 			if (hasRest) {
 				return;

package/rules/consistent-function-scoping.js

@@ -1,5 +1,5 @@
 import {getFunctionHeadLocation, getFunctionNameWithKind} from '@eslint-community/eslint-utils';
-import {getReferences, isNodeMatches} from './utils/index.js';
+import {getReferences, isNodeContainsLexicalThis, isNodeMatches} from './utils/index.js';
 import {functionTypes} from './ast/index.js';
 
 const MESSAGE_ID = 'consistent-function-scoping';
@@ -61,7 +61,7 @@ function checkReferences(scope, parent, scopeManager) {
 			return false;
 		}
 
-		// Look at the scope above the function definition to see if lives
+		// Look at the scope above the function definition to see if it lives
 		// next to the reference being checked
 		return isSameScope(parent, identifierParentScope.upper);
 	});
@@ -72,8 +72,7 @@ function checkReferences(scope, parent, scopeManager) {
 		.some(variable =>
 			hitReference(variable.references)
 			|| hitDefinitions(variable.defs)
-			|| hitIdentifier(variable.identifiers),
-		);
+			|| hitIdentifier(variable.identifiers));
 }
 
 // https://reactjs.org/docs/hooks-reference.html
@@ -94,10 +93,30 @@ const isReactHook = scope =>
 	scope.block?.parent?.callee
 	&& isNodeMatches(scope.block.parent.callee, reactHooks);
 
-const isArrowFunctionWithThis = scope =>
-	scope.type === 'function'
-	&& scope.block?.type === 'ArrowFunctionExpression'
-	&& (scope.thisFound || scope.childScopes.some(scope => isArrowFunctionWithThis(scope)));
+const isArrowFunctionNodeWithThis = (node, visitorKeys) =>
+	node.type === 'ArrowFunctionExpression'
+	// We avoid `scope.thisFound` because parser scope metadata differs; AST lexical checks are consistent.
+	// Include both params and body, because parameter defaults can reference lexical `this`.
+	&& isNodeContainsLexicalThis(node, visitorKeys);
+
+function isInsideJestMockFactory(node) {
+	let current = node;
+	while (current.parent) {
+		const {parent} = current;
+		if (
+			parent.type === 'CallExpression'
+			&& parent.arguments[1] === current
+			&& functionTypes.includes(current.type)
+			&& isNodeMatches(parent.callee, ['jest.mock'])
+		) {
+			return true;
+		}
+
+		current = parent;
+	}
+
+	return false;
+}
 
 const iifeFunctionTypes = new Set([
 	'FunctionExpression',
@@ -145,10 +164,14 @@ function handleNestedArrowFunctions(parentNode, node) {
 	return parentNode;
 }
 
-function checkNode(node, scopeManager) {
+function checkNode(node, scopeManager, sourceCode) {
 	const scope = scopeManager.acquire(node);
 
-	if (!scope || isArrowFunctionWithThis(scope)) {
+	if (
+		!scope
+		|| isArrowFunctionNodeWithThis(node, sourceCode.visitorKeys)
+		|| isInsideJestMockFactory(node)
+	) {
 		return true;
 	}
 
@@ -220,7 +243,7 @@ const create = context => {
 			return;
 		}
 
-		if (checkNode(node, scopeManager)) {
+		if (checkNode(node, scopeManager, sourceCode)) {
 			return;
 		}
 
@@ -242,6 +265,7 @@ const schema = [
 		properties: {
 			checkArrowFunctions: {
 				type: 'boolean',
+				description: 'Whether to check arrow functions.',
 			},
 		},
 	},

package/rules/consistent-json-file-read.js

@@ -0,0 +1,245 @@
+import {findVariable, getStaticValue, getPropertyName} from '@eslint-community/eslint-utils';
+import {isMethodCall} from './ast/index.js';
+import {removeArgument} from './fix/index.js';
+
+const MESSAGE_ID_STRING = 'consistent-json-file-read/string';
+const MESSAGE_ID_BUFFER = 'consistent-json-file-read/buffer';
+const messages = {
+	[MESSAGE_ID_STRING]: 'Prefer reading the JSON file as a string.',
+	[MESSAGE_ID_BUFFER]: 'Prefer reading the JSON file as a buffer.',
+};
+
+const getAwaitExpressionArgument = node => {
+	while (node.type === 'AwaitExpression') {
+		node = node.argument;
+	}
+
+	return node;
+};
+
+function getIdentifierDeclaration(node, scope) {
+	if (!node) {
+		return;
+	}
+
+	node = getAwaitExpressionArgument(node);
+
+	if (!node || node.type !== 'Identifier') {
+		return {node, scope};
+	}
+
+	const variable = findVariable(scope, node);
+	if (!variable) {
+		return;
+	}
+
+	const {identifiers, references} = variable;
+
+	if (identifiers.length !== 1 || references.length !== 2) {
+		return;
+	}
+
+	const [identifier] = identifiers;
+
+	if (
+		identifier.parent.type !== 'VariableDeclarator'
+		|| identifier.parent.id !== identifier
+	) {
+		return;
+	}
+
+	return getIdentifierDeclaration(identifier.parent.init, variable.scope);
+}
+
+const isUtf8EncodingStringNode = (node, scope) =>
+	isUtf8EncodingString(getStaticValue(node, scope)?.value);
+
+const isUtf8EncodingString = value => {
+	if (typeof value !== 'string') {
+		return false;
+	}
+
+	value = value.toLowerCase();
+
+	// eslint-disable-next-line unicorn/text-encoding-identifier-case
+	return value === 'utf8' || value === 'utf-8';
+};
+
+const isSingleEncodingOptionObject = value =>
+	value
+	&& typeof value === 'object'
+	&& Object.keys(value).length === 1
+	&& Object.hasOwn(value, 'encoding');
+
+function isUtf8Encoding(node, scope) {
+	if (
+		node.type === 'ObjectExpression'
+		&& node.properties.length === 1
+		&& node.properties[0].type === 'Property'
+		&& getPropertyName(node.properties[0], scope) === 'encoding'
+		&& isUtf8EncodingStringNode(node.properties[0].value, scope)
+	) {
+		return true;
+	}
+
+	if (isUtf8EncodingStringNode(node, scope)) {
+		return true;
+	}
+
+	const staticValue = getStaticValue(node, scope);
+	if (!staticValue) {
+		return false;
+	}
+
+	const {value} = staticValue;
+	if (
+		isSingleEncodingOptionObject(value)
+		&& isUtf8EncodingString(value.encoding)
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+function isBufferEncoding(node, scope) {
+	const staticValue = getStaticValue(node, scope);
+	if (!staticValue) {
+		return false;
+	}
+
+	const {value} = staticValue;
+	if (value === undefined || value === null) {
+		return true;
+	}
+
+	if (
+		isSingleEncodingOptionObject(value)
+		&& (value.encoding === undefined || value.encoding === null)
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+function isJsonReadFileCall(node, scope) {
+	if (
+		!(
+			node
+			&& node.type === 'CallExpression'
+			&& !node.optional
+			&& (node.arguments.length === 1 || node.arguments.length === 2)
+			&& !node.arguments.some(node => node.type === 'SpreadElement')
+			&& node.callee.type === 'MemberExpression'
+			&& !node.callee.optional
+		)
+	) {
+		return false;
+	}
+
+	const method = getPropertyName(node.callee, scope);
+	return method === 'readFile' || method === 'readFileSync';
+}
+
+function addUtf8Encoding(fixer, callExpression, context) {
+	const {sourceCode} = context;
+	const [fileNode] = callExpression.arguments;
+	const tokenAfterFile = sourceCode.getTokenAfter(fileNode);
+
+	if (tokenAfterFile.value === ',') {
+		return fixer.insertTextAfter(tokenAfterFile, ' \'utf8\'');
+	}
+
+	return fixer.insertTextAfter(fileNode, ', \'utf8\'');
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const [option] = context.options;
+
+	context.on('CallExpression', callExpression => {
+		if (!(isMethodCall(callExpression, {
+			object: 'JSON',
+			method: 'parse',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		}))) {
+			return;
+		}
+
+		const [argument] = callExpression.arguments;
+		const {sourceCode} = context;
+		const resolved = getIdentifierDeclaration(argument, sourceCode.getScope(argument));
+		if (!resolved) {
+			return;
+		}
+
+		const {node, scope} = resolved;
+		if (!isJsonReadFileCall(node, scope)) {
+			return;
+		}
+
+		if (option === 'string') {
+			if (node.arguments.length === 1) {
+				return {
+					node,
+					messageId: MESSAGE_ID_STRING,
+					fix: fixer => addUtf8Encoding(fixer, node, context),
+				};
+			}
+
+			const [, optionsNode] = node.arguments;
+			if (!isBufferEncoding(optionsNode, scope)) {
+				return;
+			}
+
+			return {
+				node: optionsNode,
+				messageId: MESSAGE_ID_STRING,
+				fix: fixer => fixer.replaceText(optionsNode, '\'utf8\''),
+			};
+		}
+
+		if (node.arguments.length !== 2) {
+			return;
+		}
+
+		const [, charsetNode] = node.arguments;
+		if (!isUtf8Encoding(charsetNode, scope)) {
+			return;
+		}
+
+		return {
+			node: charsetNode,
+			messageId: MESSAGE_ID_BUFFER,
+			fix: fixer => removeArgument(fixer, charsetNode, context),
+		};
+	});
+};
+
+const schema = [
+	{
+		enum: ['string', 'buffer'],
+		description: 'Whether to prefer reading JSON files as strings or buffers before passing them to `JSON.parse()`.',
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent JSON file reads before `JSON.parse()`.',
+			recommended: true,
+		},
+		fixable: 'code',
+		schema,
+		defaultOptions: ['string'],
+		messages,
+	},
+};
+
+export default config;

package/rules/consistent-template-literal-escape.js

@@ -0,0 +1,52 @@
+import {replaceTemplateElement} from './fix/index.js';
+import {isTaggedTemplateLiteral} from './ast/index.js';
+
+const MESSAGE_ID = 'consistent-template-literal-escape';
+const messages = {
+	[MESSAGE_ID]: 'Use `\\${` instead of `$\\{` to escape in template literals.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on('TemplateElement', node => {
+		if (isTaggedTemplateLiteral(node.parent)) {
+			return;
+		}
+
+		const {raw} = node.value;
+
+		// Match `$\{` or `\$\{` and replace with `\${`.
+		// The `\\?` makes the leading backslash optional to handle both patterns.
+		// The lookbehind ensures an even number of preceding backslashes (including zero).
+		const fixedRaw = raw.replaceAll(
+			/(?<=(?:^|[^\\])(?:\\\\)*)\\?\$\\{/g,
+			String.raw`\${`,
+		);
+
+		if (raw !== fixedRaw) {
+			const problem = {
+				node,
+				messageId: MESSAGE_ID,
+				fix: fixer => replaceTemplateElement(node, fixedRaw, context, fixer),
+			};
+
+			return problem;
+		}
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent style for escaping `${` in template literals.',
+			recommended: true,
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;