eslint-plugin-unicorn 64.0.0 → 65.0.0

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/custom-error-definition.js

@@ -3,10 +3,15 @@ import {
 	getParenthesizedText,
 	isNodeMatchesNameOrPath,
 } from './utils/index.js';
+import {isUndefined} from './ast/index.js';
 
 const MESSAGE_ID_INVALID_EXPORT = 'invalidExport';
+const MESSAGE_ID_DO_NOT_PASS_MESSAGE_TO_SUPER = 'doNotPassMessageToSuper';
+const MESSAGE_ID_DO_NOT_ASSIGN_MESSAGE_WITHOUT_SETTER = 'doNotAssignMessageWithoutSetter';
 const messages = {
 	[MESSAGE_ID_INVALID_EXPORT]: 'Exported error name should match error class',
+	[MESSAGE_ID_DO_NOT_PASS_MESSAGE_TO_SUPER]: 'Do not pass the error message to `super()` when the class defines a `message` accessor.',
+	[MESSAGE_ID_DO_NOT_ASSIGN_MESSAGE_WITHOUT_SETTER]: 'Do not assign to `this.message` when the class defines a `message` getter without a setter.',
 };
 
 const nameRegexp = /^(?:[A-Z][\da-z]*)*Error$/;
@@ -44,6 +49,7 @@ const isSuperExpression = node =>
 const isAssignmentExpression = (node, name) =>
 	node.type === 'ExpressionStatement'
 	&& node.expression.type === 'AssignmentExpression'
+	&& node.expression.operator === '='
 	&& isNodeMatchesNameOrPath(node.expression.left, `this.${name}`);
 
 const createInvalidNameError = (node, name) => ({
@@ -62,7 +68,52 @@ const isValidNameProperty = (nameProperty, className) =>
 	nameProperty?.value
 	&& nameProperty.value.value === className;
 
-function * checkConstructorBody(context, constructor, name, nameProperty) {
+const isMessageAccessor = (node, kind) =>
+	node.type === 'MethodDefinition'
+	&& node.kind === kind
+	&& !node.static
+	&& !node.computed
+	&& node.key.type === 'Identifier'
+	&& node.key.name === 'message';
+
+const isMissingOrUndefined = node =>
+	!node
+	|| isUndefined(node);
+
+const isSameText = (left, right, sourceCode) =>
+	sourceCode.getText(left) === sourceCode.getText(right);
+
+const hasThisOrSuper = (node, visitorKeys) => {
+	if (node.type === 'ThisExpression' || node.type === 'Super') {
+		return true;
+	}
+
+	const keys = visitorKeys[node.type] ?? [];
+
+	for (const key of keys) {
+		const value = node[key];
+
+		if (!value) {
+			continue;
+		}
+
+		if (Array.isArray(value)) {
+			if (value.some(childNode => childNode && hasThisOrSuper(childNode, visitorKeys))) {
+				return true;
+			}
+
+			continue;
+		}
+
+		if (hasThisOrSuper(value, visitorKeys)) {
+			return true;
+		}
+	}
+
+	return false;
+};
+
+function * checkConstructorBody(context, constructor, errorDefinition) {
 	const {sourceCode} = context;
 	const constructorBodyNode = constructor.value.body;
 
@@ -72,24 +123,49 @@ function * checkConstructorBody(context, constructor, name, nameProperty) {
 	}
 
 	const constructorBody = constructorBodyNode.body;
+	const {name, nameProperty, hasMessageGetter, hasMessageSetter} = errorDefinition;
 
 	const superExpression = constructorBody.find(bodyNode => isSuperExpression(bodyNode));
+	const superExpressionIndex = constructorBody.findIndex(bodyNode => isSuperExpression(bodyNode));
 	const messageExpressionIndex = constructorBody.findIndex(bodyNode => isAssignmentExpression(bodyNode, 'message'));
+	const hasMessageAccessor = hasMessageGetter || hasMessageSetter;
 
 	if (!superExpression) {
 		yield {
 			node: constructorBodyNode,
 			message: 'Missing call to `super()` in constructor.',
 		};
-	} else if (messageExpressionIndex !== -1) {
+	} else if (hasMessageAccessor && !isMissingOrUndefined(superExpression.expression.arguments[0])) {
+		yield {
+			node: superExpression,
+			messageId: MESSAGE_ID_DO_NOT_PASS_MESSAGE_TO_SUPER,
+		};
+	} else if (
+		hasMessageGetter
+		&& !hasMessageSetter
+		&& messageExpressionIndex !== -1
+	) {
+		yield {
+			node: constructorBody[messageExpressionIndex],
+			messageId: MESSAGE_ID_DO_NOT_ASSIGN_MESSAGE_WITHOUT_SETTER,
+		};
+	} else if (!hasMessageSetter && messageExpressionIndex !== -1) {
 		const expression = constructorBody[messageExpressionIndex];
 
 		yield {
 			node: superExpression,
 			message: 'Pass the error message to `super()` instead of setting `this.message`.',
 			* fix(fixer) {
+				const rhs = expression.expression.right;
+
 				if (superExpression.expression.arguments.length === 0) {
-					const rhs = expression.expression.right;
+					if (
+						messageExpressionIndex !== superExpressionIndex + 1
+						|| hasThisOrSuper(rhs, sourceCode.visitorKeys)
+					) {
+						return;
+					}
+
 					const [start] = sourceCode.getRange(superExpression);
 					// This part crashes on ESLint 10, but it's still not correct.
 					// There can be spaces, comments after `super`
@@ -97,6 +173,8 @@ function * checkConstructorBody(context, constructor, name, nameProperty) {
 						[start, start + 6],
 						getParenthesizedText(rhs, context),
 					);
+				} else if (!isSameText(superExpression.expression.arguments[0], rhs, sourceCode)) {
+					return;
 				}
 
 				const start = messageExpressionIndex === 0
@@ -148,6 +226,8 @@ function * customErrorDefinition(context, node) {
 	const {sourceCode} = context;
 	const constructor = body.find(x => x.kind === 'constructor');
 	const nameProperty = body.find(classNode => isPropertyDefinition(classNode, 'name'));
+	const hasMessageGetter = body.some(classNode => isMessageAccessor(classNode, 'get'));
+	const hasMessageSetter = body.some(classNode => isMessageAccessor(classNode, 'set'));
 
 	if (!constructor) {
 		if (isValidNameProperty(nameProperty, name)) {
@@ -176,7 +256,12 @@ function * customErrorDefinition(context, node) {
 		return;
 	}
 
-	yield * checkConstructorBody(context, constructor, name, nameProperty);
+	yield * checkConstructorBody(context, constructor, {
+		name,
+		nameProperty,
+		hasMessageGetter,
+		hasMessageSetter,
+	});
 }
 
 const customErrorExport = (context, node) => {