eslint-plugin-unicorn-ts 0.0.1-security → 50.0.1

package/rules/prefer-modern-math-apis.js

@@ -0,0 +1,212 @@
+'use strict';
+const {
+	getParenthesizedText,
+	getParenthesizedRange,
+	isSameReference,
+} = require('./utils/index.js');
+const {isLiteral, isMethodCall} = require('./ast/index.js');
+const {replaceNodeOrTokenAndSpacesBefore, removeParentheses} = require('./fix/index.js');
+
+const MESSAGE_ID = 'prefer-modern-math-apis';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `{{replacement}}` over `{{description}}`.',
+};
+
+const isMathProperty = (node, property) =>
+	node.type === 'MemberExpression'
+	&& !node.optional
+	&& !node.computed
+	&& node.object.type === 'Identifier'
+	&& node.object.name === 'Math'
+	&& node.property.type === 'Identifier'
+	&& node.property.name === property;
+
+const isMathMethodCall = (node, method) =>
+	node.type === 'CallExpression'
+	&& !node.optional
+	&& isMathProperty(node.callee, method)
+	&& node.arguments.length === 1
+	&& node.arguments[0].type !== 'SpreadElement';
+
+// `Math.log(x) * Math.LOG10E` -> `Math.log10(x)`
+// `Math.LOG10E * Math.log(x)` -> `Math.log10(x)`
+// `Math.log(x) * Math.LOG2E` -> `Math.log2(x)`
+// `Math.LOG2E * Math.log(x)` -> `Math.log2(x)`
+function createLogCallTimesConstantCheck({constantName, replacementMethod}) {
+	const replacement = `Math.${replacementMethod}(…)`;
+
+	return function (node, context) {
+		if (!(node.type === 'BinaryExpression' && node.operator === '*')) {
+			return;
+		}
+
+		let mathLogCall;
+		let description;
+		if (isMathMethodCall(node.left, 'log') && isMathProperty(node.right, constantName)) {
+			mathLogCall = node.left;
+			description = `Math.log(…) * Math.${constantName}`;
+		} else if (isMathMethodCall(node.right, 'log') && isMathProperty(node.left, constantName)) {
+			mathLogCall = node.right;
+			description = `Math.${constantName} * Math.log(…)`;
+		}
+
+		if (!mathLogCall) {
+			return;
+		}
+
+		const [valueNode] = mathLogCall.arguments;
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			data: {
+				replacement,
+				description,
+			},
+			fix: fixer => fixer.replaceText(node, `Math.${replacementMethod}(${getParenthesizedText(valueNode, context.sourceCode)})`),
+		};
+	};
+}
+
+// `Math.log(x) / Math.LN10` -> `Math.log10(x)`
+// `Math.log(x) / Math.LN2` -> `Math.log2(x)`
+function createLogCallDivideConstantCheck({constantName, replacementMethod}) {
+	const message = {
+		messageId: MESSAGE_ID,
+		data: {
+			replacement: `Math.${replacementMethod}(…)`,
+			description: `Math.log(…) / Math.${constantName}`,
+		},
+	};
+
+	return function (node, context) {
+		if (
+			!(
+				node.type === 'BinaryExpression'
+				&& node.operator === '/'
+				&& isMathMethodCall(node.left, 'log')
+				&& isMathProperty(node.right, constantName)
+			)
+		) {
+			return;
+		}
+
+		const [valueNode] = node.left.arguments;
+
+		return {
+			...message,
+			node,
+			fix: fixer => fixer.replaceText(node, `Math.${replacementMethod}(${getParenthesizedText(valueNode, context.sourceCode)})`),
+		};
+	};
+}
+
+const checkFunctions = [
+	createLogCallTimesConstantCheck({constantName: 'LOG10E', replacementMethod: 'log10'}),
+	createLogCallTimesConstantCheck({constantName: 'LOG2E', replacementMethod: 'log2'}),
+	createLogCallDivideConstantCheck({constantName: 'LN10', replacementMethod: 'log10'}),
+	createLogCallDivideConstantCheck({constantName: 'LN2', replacementMethod: 'log2'}),
+];
+
+const isPlusExpression = node => node.type === 'BinaryExpression' && node.operator === '+';
+
+const isPow2Expression = node =>
+	node.type === 'BinaryExpression'
+	&& (
+		// `x * x`
+		(node.operator === '*' && isSameReference(node.left, node.right))
+		// `x ** 2`
+		|| (node.operator === '**' && isLiteral(node.right, 2))
+	);
+
+const flatPlusExpression = node =>
+	isPlusExpression(node)
+		? [node.left, node.right].flatMap(child => flatPlusExpression(child))
+		: [node];
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const nodes = [];
+
+	return {
+		CallExpression(callExpression) {
+			if (!isMethodCall(callExpression, {
+				object: 'Math',
+				method: 'sqrt',
+				argumentsLength: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})) {
+				return;
+			}
+
+			const expressions = flatPlusExpression(callExpression.arguments[0]);
+			if (expressions.some(expression => !isPow2Expression(expression))) {
+				return;
+			}
+
+			const replacementMethod = expressions.length === 1 ? 'abs' : 'hypot';
+			const plusExpressions = new Set(expressions.length === 1 ? [] : expressions.map(expression => expression.parent));
+
+			return {
+				node: callExpression.callee.property,
+				messageId: MESSAGE_ID,
+				data: {
+					replacement: `Math.${replacementMethod}(…)`,
+					description: 'Math.sqrt(…)',
+				},
+				* fix(fixer) {
+					const {sourceCode} = context;
+
+					// `Math.sqrt` -> `Math.{hypot,abs}`
+					yield fixer.replaceText(callExpression.callee.property, replacementMethod);
+
+					// `a ** 2 + b ** 2` -> `a, b`
+					for (const expression of plusExpressions) {
+						const plusToken = sourceCode.getTokenAfter(expression.left, token => token.type === 'Punctuator' && token.value === '+');
+
+						yield * replaceNodeOrTokenAndSpacesBefore(plusToken, ',', fixer, sourceCode);
+						yield * removeParentheses(expression, fixer, sourceCode);
+					}
+
+					// `x ** 2` => `x`
+					// `x * a` => `x`
+					for (const expression of expressions) {
+						yield fixer.removeRange([
+							getParenthesizedRange(expression.left, sourceCode)[1],
+							expression.range[1],
+						]);
+					}
+				},
+			};
+		},
+
+		BinaryExpression(node) {
+			nodes.push(node);
+		},
+		* 'Program:exit'() {
+			for (const node of nodes) {
+				for (const getProblem of checkFunctions) {
+					const problem = getProblem(node, context);
+
+					if (problem) {
+						yield problem;
+					}
+				}
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer modern `Math` APIs over legacy patterns.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-module.js

@@ -0,0 +1,349 @@
+'use strict';
+const {isOpeningParenToken} = require('@eslint-community/eslint-utils');
+const isShadowed = require('./utils/is-shadowed.js');
+const assertToken = require('./utils/assert-token.js');
+const {isStaticRequire, isReferenceIdentifier, isFunction} = require('./ast/index.js');
+const {
+	removeParentheses,
+	replaceReferenceIdentifier,
+	removeSpacesAfter,
+} = require('./fix/index.js');
+
+const ERROR_USE_STRICT_DIRECTIVE = 'error/use-strict-directive';
+const ERROR_GLOBAL_RETURN = 'error/global-return';
+const ERROR_IDENTIFIER = 'error/identifier';
+const SUGGESTION_USE_STRICT_DIRECTIVE = 'suggestion/use-strict-directive';
+const SUGGESTION_DIRNAME = 'suggestion/dirname';
+const SUGGESTION_FILENAME = 'suggestion/filename';
+const SUGGESTION_IMPORT = 'suggestion/import';
+const SUGGESTION_EXPORT = 'suggestion/export';
+const messages = {
+	[ERROR_USE_STRICT_DIRECTIVE]: 'Do not use "use strict" directive.',
+	[ERROR_GLOBAL_RETURN]: '"return" should be used inside a function.',
+	[ERROR_IDENTIFIER]: 'Do not use "{{name}}".',
+	[SUGGESTION_USE_STRICT_DIRECTIVE]: 'Remove "use strict" directive.',
+	[SUGGESTION_DIRNAME]: 'Replace "__dirname" with `"…(import.meta.url)"`.',
+	[SUGGESTION_FILENAME]: 'Replace "__filename" with `"…(import.meta.url)"`.',
+	[SUGGESTION_IMPORT]: 'Switch to `import`.',
+	[SUGGESTION_EXPORT]: 'Switch to `export`.',
+};
+
+function fixRequireCall(node, sourceCode) {
+	if (!isStaticRequire(node.parent) || node.parent.callee !== node) {
+		return;
+	}
+
+	const requireCall = node.parent;
+	const {
+		parent,
+		callee,
+		arguments: [source],
+	} = requireCall;
+
+	// `require("foo")`
+	if (parent.type === 'ExpressionStatement' && parent.parent.type === 'Program') {
+		return function * (fixer) {
+			yield fixer.replaceText(callee, 'import');
+			const openingParenthesisToken = sourceCode.getTokenAfter(
+				callee,
+				isOpeningParenToken,
+			);
+			yield fixer.replaceText(openingParenthesisToken, ' ');
+			const closingParenthesisToken = sourceCode.getLastToken(requireCall);
+			yield fixer.remove(closingParenthesisToken);
+
+			for (const node of [callee, requireCall, source]) {
+				yield * removeParentheses(node, fixer, sourceCode);
+			}
+		};
+	}
+
+	// `const foo = require("foo")`
+	// `const {foo} = require("foo")`
+	if (
+		parent.type === 'VariableDeclarator'
+		&& parent.init === requireCall
+		&& (
+			parent.id.type === 'Identifier'
+			|| (
+				parent.id.type === 'ObjectPattern'
+				&& parent.id.properties.every(
+					({type, key, value, computed}) =>
+						type === 'Property'
+						&& !computed
+						&& value.type === 'Identifier'
+						&& key.type === 'Identifier',
+				)
+			)
+		)
+		&& parent.parent.type === 'VariableDeclaration'
+		&& parent.parent.kind === 'const'
+		&& parent.parent.declarations.length === 1
+		&& parent.parent.declarations[0] === parent
+		&& parent.parent.parent.type === 'Program'
+	) {
+		const declarator = parent;
+		const declaration = declarator.parent;
+		const {id} = declarator;
+
+		return function * (fixer) {
+			const constToken = sourceCode.getFirstToken(declaration);
+			assertToken(constToken, {
+				expected: {type: 'Keyword', value: 'const'},
+				ruleId: 'prefer-module',
+			});
+			yield fixer.replaceText(constToken, 'import');
+
+			const equalToken = sourceCode.getTokenAfter(id);
+			assertToken(equalToken, {
+				expected: {type: 'Punctuator', value: '='},
+				ruleId: 'prefer-module',
+			});
+			yield removeSpacesAfter(id, sourceCode, fixer);
+			yield removeSpacesAfter(equalToken, sourceCode, fixer);
+			yield fixer.replaceText(equalToken, ' from ');
+
+			yield fixer.remove(callee);
+			const openingParenthesisToken = sourceCode.getTokenAfter(
+				callee,
+				isOpeningParenToken,
+			);
+			yield fixer.remove(openingParenthesisToken);
+			const closingParenthesisToken = sourceCode.getLastToken(requireCall);
+			yield fixer.remove(closingParenthesisToken);
+
+			for (const node of [callee, requireCall, source]) {
+				yield * removeParentheses(node, fixer, sourceCode);
+			}
+
+			if (id.type === 'Identifier') {
+				return;
+			}
+
+			const {properties} = id;
+
+			for (const property of properties) {
+				const {key, shorthand} = property;
+				if (!shorthand) {
+					const commaToken = sourceCode.getTokenAfter(key);
+					assertToken(commaToken, {
+						expected: {type: 'Punctuator', value: ':'},
+						ruleId: 'prefer-module',
+					});
+					yield removeSpacesAfter(key, sourceCode, fixer);
+					yield removeSpacesAfter(commaToken, sourceCode, fixer);
+					yield fixer.replaceText(commaToken, ' as ');
+				}
+			}
+		};
+	}
+}
+
+const isTopLevelAssignment = node =>
+	node.parent.type === 'AssignmentExpression'
+	&& node.parent.operator === '='
+	&& node.parent.left === node
+	&& node.parent.parent.type === 'ExpressionStatement'
+	&& node.parent.parent.parent.type === 'Program';
+const isNamedExport = node =>
+	node.parent.type === 'MemberExpression'
+	&& !node.parent.optional
+	&& !node.parent.computed
+	&& node.parent.object === node
+	&& node.parent.property.type === 'Identifier'
+	&& isTopLevelAssignment(node.parent)
+	&& node.parent.parent.right.type === 'Identifier';
+const isModuleExports = node =>
+	node.parent.type === 'MemberExpression'
+	&& !node.parent.optional
+	&& !node.parent.computed
+	&& node.parent.object === node
+	&& node.parent.property.type === 'Identifier'
+	&& node.parent.property.name === 'exports';
+const isTopLevelReturnStatement = node => {
+	for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+		if (isFunction(ancestor)) {
+			return false;
+		}
+	}
+
+	return true;
+};
+
+function fixDefaultExport(node, sourceCode) {
+	return function * (fixer) {
+		yield fixer.replaceText(node, 'export default ');
+		yield removeSpacesAfter(node, sourceCode, fixer);
+
+		const equalToken = sourceCode.getTokenAfter(node, token => token.type === 'Punctuator' && token.value === '=');
+		yield fixer.remove(equalToken);
+		yield removeSpacesAfter(equalToken, sourceCode, fixer);
+
+		for (const currentNode of [node.parent, node]) {
+			yield * removeParentheses(currentNode, fixer, sourceCode);
+		}
+	};
+}
+
+function fixNamedExport(node, sourceCode) {
+	return function * (fixer) {
+		const assignmentExpression = node.parent.parent;
+		const exported = node.parent.property.name;
+		const local = assignmentExpression.right.name;
+		yield fixer.replaceText(assignmentExpression, `export {${local} as ${exported}}`);
+
+		yield * removeParentheses(assignmentExpression, fixer, sourceCode);
+	};
+}
+
+function fixExports(node, sourceCode) {
+	// `exports = bar`
+	if (isTopLevelAssignment(node)) {
+		return fixDefaultExport(node, sourceCode);
+	}
+
+	// `exports.foo = bar`
+	if (isNamedExport(node)) {
+		return fixNamedExport(node, sourceCode);
+	}
+}
+
+function fixModuleExports(node, sourceCode) {
+	if (isModuleExports(node)) {
+		return fixExports(node.parent, sourceCode);
+	}
+}
+
+function create(context) {
+	const filename = context.filename.toLowerCase();
+
+	if (filename.endsWith('.cjs')) {
+		return;
+	}
+
+	const {sourceCode} = context;
+
+	context.on('ExpressionStatement', node => {
+		if (node.directive !== 'use strict') {
+			return;
+		}
+
+		const problem = {node, messageId: ERROR_USE_STRICT_DIRECTIVE};
+		const fix = function * (fixer) {
+			yield fixer.remove(node);
+			yield removeSpacesAfter(node, sourceCode, fixer);
+		};
+
+		if (filename.endsWith('.mjs')) {
+			problem.fix = fix;
+		} else {
+			problem.suggest = [{messageId: SUGGESTION_USE_STRICT_DIRECTIVE, fix}];
+		}
+
+		return problem;
+	});
+
+	context.on('ReturnStatement', node => {
+		if (isTopLevelReturnStatement(node)) {
+			return {
+				node: sourceCode.getFirstToken(node),
+				messageId: ERROR_GLOBAL_RETURN,
+			};
+		}
+	});
+
+	context.on('Identifier', node => {
+		if (
+			!isReferenceIdentifier(node, [
+				'exports',
+				'require',
+				'module',
+				'__filename',
+				'__dirname',
+			])
+			|| isShadowed(sourceCode.getScope(node), node)
+		) {
+			return;
+		}
+
+		const {name} = node;
+
+		const problem = {
+			node,
+			messageId: ERROR_IDENTIFIER,
+			data: {name},
+		};
+
+		switch (name) {
+			case '__filename':
+			case '__dirname': {
+				const messageId = node.name === '__dirname' ? SUGGESTION_DIRNAME : SUGGESTION_FILENAME;
+				const replacement = node.name === '__dirname'
+					? 'path.dirname(url.fileURLToPath(import.meta.url))'
+					: 'url.fileURLToPath(import.meta.url)';
+				problem.suggest = [{
+					messageId,
+					fix: fixer => replaceReferenceIdentifier(node, replacement, fixer),
+				}];
+				return problem;
+			}
+
+			case 'require': {
+				const fix = fixRequireCall(node, sourceCode);
+				if (fix) {
+					problem.suggest = [{
+						messageId: SUGGESTION_IMPORT,
+						fix,
+					}];
+					return problem;
+				}
+
+				break;
+			}
+
+			case 'exports': {
+				const fix = fixExports(node, sourceCode);
+				if (fix) {
+					problem.suggest = [{
+						messageId: SUGGESTION_EXPORT,
+						fix,
+					}];
+					return problem;
+				}
+
+				break;
+			}
+
+			case 'module': {
+				const fix = fixModuleExports(node, sourceCode);
+				if (fix) {
+					problem.suggest = [{
+						messageId: SUGGESTION_EXPORT,
+						fix,
+					}];
+					return problem;
+				}
+
+				break;
+			}
+
+			default:
+		}
+
+		return problem;
+	});
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer JavaScript modules (ESM) over CommonJS.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};