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

package/rules/prefer-native-coercion-functions.js

@@ -0,0 +1,185 @@
+'use strict';
+const {getFunctionHeadLocation, getFunctionNameWithKind} = require('@eslint-community/eslint-utils');
+const {functionTypes} = require('./ast/index.js');
+
+const MESSAGE_ID = 'prefer-native-coercion-functions';
+const messages = {
+	[MESSAGE_ID]: '{{functionNameWithKind}} is equivalent to `{{replacementFunction}}`. Use `{{replacementFunction}}` directly.',
+};
+
+const nativeCoercionFunctionNames = new Set(['String', 'Number', 'BigInt', 'Boolean', 'Symbol']);
+const arrayMethodsWithBooleanCallback = new Set(['every', 'filter', 'find', 'findLast', 'findIndex', 'findLastIndex', 'some']);
+
+const isNativeCoercionFunctionCall = (node, firstArgumentName) =>
+	node?.type === 'CallExpression'
+	&& !node.optional
+	&& node.callee.type === 'Identifier'
+	&& nativeCoercionFunctionNames.has(node.callee.name)
+	&& node.arguments[0]?.type === 'Identifier'
+	&& node.arguments[0].name === firstArgumentName;
+
+const isIdentityFunction = node =>
+	(
+		// `v => v`
+		node.type === 'ArrowFunctionExpression'
+		&& node.body.type === 'Identifier'
+		&& node.body.name === node.params[0].name
+	)
+	|| (
+		// `(v) => {return v;}`
+		// `function (v) {return v;}`
+		node.body.type === 'BlockStatement'
+		&& node.body.body.length === 1
+		&& node.body.body[0].type === 'ReturnStatement'
+		&& node.body.body[0].argument?.type === 'Identifier'
+		&& node.body.body[0].argument.name === node.params[0].name
+	);
+
+const isArrayIdentityCallback = node =>
+	isIdentityFunction(node)
+	&& node.parent.type === 'CallExpression'
+	&& !node.parent.optional
+	&& node.parent.arguments[0] === node
+	&& node.parent.callee.type === 'MemberExpression'
+	&& !node.parent.callee.computed
+	&& !node.parent.callee.optional
+	&& node.parent.callee.property.type === 'Identifier'
+	&& arrayMethodsWithBooleanCallback.has(node.parent.callee.property.name);
+
+function getCallExpression(node) {
+	const firstParameterName = node.params[0].name;
+
+	// `(v) => String(v)`
+	if (
+		node.type === 'ArrowFunctionExpression'
+		&& isNativeCoercionFunctionCall(node.body, firstParameterName)
+	) {
+		return node.body;
+	}
+
+	// `(v) => {return String(v);}`
+	// `function (v) {return String(v);}`
+	if (
+		node.body.type === 'BlockStatement'
+		&& node.body.body.length === 1
+		&& node.body.body[0].type === 'ReturnStatement'
+		&& isNativeCoercionFunctionCall(node.body.body[0].argument, firstParameterName)
+	) {
+		return node.body.body[0].argument;
+	}
+}
+
+function getArrayCallbackProblem(node) {
+	if (!isArrayIdentityCallback(node)) {
+		return;
+	}
+
+	return {
+		replacementFunction: 'Boolean',
+		fix: fixer => fixer.replaceText(node, 'Boolean'),
+	};
+}
+
+function getCoercionFunctionProblem(node) {
+	const callExpression = getCallExpression(node);
+
+	if (!callExpression) {
+		return;
+	}
+
+	const {name} = callExpression.callee;
+
+	const problem = {replacementFunction: name};
+
+	if (node.type === 'FunctionDeclaration' || callExpression.arguments.length !== 1) {
+		return problem;
+	}
+
+	/** @param {import('eslint').Rule.RuleFixer} fixer */
+	problem.fix = fixer => {
+		let text = name;
+
+		if (
+			node.parent.type === 'Property'
+			&& node.parent.method
+			&& node.parent.value === node
+		) {
+			text = `: ${text}`;
+		} else if (node.parent.type === 'MethodDefinition') {
+			text = ` = ${text};`;
+		}
+
+		return fixer.replaceText(node, text);
+	};
+
+	return problem;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	context.on(functionTypes, node => {
+		if (
+			node.async
+			|| node.generator
+			|| node.params.length === 0
+			|| node.params[0].type !== 'Identifier'
+			|| (
+				(
+					(
+						node.parent.type === 'MethodDefinition'
+						&& (node.parent.kind === 'constructor' || node.parent.kind === 'set')
+					)
+					|| (node.parent.type === 'Property' && node.parent.kind === 'set')
+				)
+				&& node.parent.value === node
+			)
+		) {
+			return;
+		}
+
+		let problem = getArrayCallbackProblem(node) || getCoercionFunctionProblem(node);
+
+		if (!problem) {
+			return;
+		}
+
+		const {sourceCode} = context;
+		const {replacementFunction, fix} = problem;
+
+		problem = {
+			node,
+			loc: getFunctionHeadLocation(node, sourceCode),
+			messageId: MESSAGE_ID,
+			data: {
+				functionNameWithKind: getFunctionNameWithKind(node, sourceCode),
+				replacementFunction,
+			},
+		};
+
+		/*
+		We do not fix if there are:
+		- Comments: No proper place to put them.
+		- Extra parameters: Removing them may break types.
+		*/
+		if (!fix || node.params.length !== 1 || sourceCode.getCommentsInside(node).length > 0) {
+			return problem;
+		}
+
+		problem.fix = fix;
+
+		return problem;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer using `String`, `Number`, `BigInt`, `Boolean`, and `Symbol` directly.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-negative-index.js

@@ -0,0 +1,213 @@
+'use strict';
+const {
+	getNegativeIndexLengthNode,
+	removeLengthNode,
+} = require('./shared/negative-index.js');
+const typedArray = require('./shared/typed-array.js');
+const {isLiteral} = require('./ast/index.js');
+
+const MESSAGE_ID = 'prefer-negative-index';
+const messages = {
+	[MESSAGE_ID]: 'Prefer negative index over length minus index for `{{method}}`.',
+};
+
+const methods = new Map([
+	[
+		'slice',
+		{
+			argumentsIndexes: [0, 1],
+			supportObjects: new Set([
+				'Array',
+				'String',
+				'ArrayBuffer',
+				...typedArray,
+				// `{Blob,File}#slice()` are not generally used
+				// 'Blob'
+				// 'File'
+			]),
+		},
+	],
+	[
+		'subarray',
+		{
+			argumentsIndexes: [0, 1],
+			supportObjects: new Set(typedArray),
+		},
+	],
+	[
+		'splice',
+		{
+			argumentsIndexes: [0],
+			supportObjects: new Set([
+				'Array',
+			]),
+		},
+	],
+	[
+		'toSpliced',
+		{
+			argumentsIndexes: [0],
+			supportObjects: new Set([
+				'Array',
+			]),
+		},
+	],
+	[
+		'at',
+		{
+			argumentsIndexes: [0],
+			supportObjects: new Set([
+				'Array',
+				'String',
+				...typedArray,
+			]),
+		},
+	],
+	[
+		'with',
+		{
+			argumentsIndexes: [0],
+			supportObjects: new Set([
+				'Array',
+				...typedArray,
+			]),
+		},
+	],
+]);
+
+const getMemberName = node => {
+	const {type, property} = node;
+
+	if (
+		type === 'MemberExpression'
+		&& property.type === 'Identifier'
+	) {
+		return property.name;
+	}
+};
+
+function parse(node) {
+	const {callee, arguments: originalArguments} = node;
+
+	let method = callee.property.name;
+	let target = callee.object;
+	let argumentsNodes = originalArguments;
+
+	if (methods.has(method)) {
+		return {
+			method,
+			target,
+			argumentsNodes,
+		};
+	}
+
+	if (method !== 'call' && method !== 'apply') {
+		return;
+	}
+
+	const isApply = method === 'apply';
+
+	method = getMemberName(callee.object);
+
+	if (!methods.has(method)) {
+		return;
+	}
+
+	const {supportObjects} = methods.get(method);
+
+	const parentCallee = callee.object.object;
+
+	if (
+		// `[].{slice,splice,toSpliced,at,with}`
+		(
+			parentCallee.type === 'ArrayExpression'
+			&& parentCallee.elements.length === 0
+		)
+		// `''.slice`
+		|| (
+			method === 'slice'
+			&& isLiteral(parentCallee, '')
+		)
+		// {Array,String...}.prototype.slice
+		// Array.prototype.splice
+		|| (
+			getMemberName(parentCallee) === 'prototype'
+			&& parentCallee.object.type === 'Identifier'
+			&& supportObjects.has(parentCallee.object.name)
+		)
+	) {
+		[target] = originalArguments;
+
+		if (isApply) {
+			const [, secondArgument] = originalArguments;
+			if (!secondArgument || secondArgument.type !== 'ArrayExpression') {
+				return;
+			}
+
+			argumentsNodes = secondArgument.elements;
+		} else {
+			argumentsNodes = originalArguments.slice(1);
+		}
+
+		return {
+			method,
+			target,
+			argumentsNodes,
+		};
+	}
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(node) {
+		if (node.callee.type !== 'MemberExpression') {
+			return;
+		}
+
+		const parsed = parse(node);
+
+		if (!parsed) {
+			return;
+		}
+
+		const {
+			method,
+			target,
+			argumentsNodes,
+		} = parsed;
+
+		const {argumentsIndexes} = methods.get(method);
+		const removableNodes = argumentsIndexes
+			.map(index => getNegativeIndexLengthNode(argumentsNodes[index], target))
+			.filter(Boolean);
+
+		if (removableNodes.length === 0) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			data: {method},
+			* fix(fixer) {
+				const {sourceCode} = context;
+				for (const node of removableNodes) {
+					yield removeLengthNode(node, fixer, sourceCode);
+				}
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer negative index over `.length - index` when possible.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-node-protocol.js

@@ -0,0 +1,61 @@
+'use strict';
+const isBuiltinModule = require('is-builtin-module');
+const {replaceStringLiteral} = require('./fix/index.js');
+const isStaticRequire = require('./ast/is-static-require.js');
+
+const MESSAGE_ID = 'prefer-node-protocol';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `node:{{moduleName}}` over `{{moduleName}}`.',
+};
+
+const create = () => ({
+	Literal(node) {
+		if (!(
+			(
+				(
+					node.parent.type === 'ImportDeclaration'
+					|| node.parent.type === 'ExportNamedDeclaration'
+					|| node.parent.type === 'ImportExpression'
+				)
+				&& node.parent.source === node
+			)
+			|| (
+				isStaticRequire(node.parent)
+				&& node.parent.arguments[0] === node
+			)
+		)) {
+			return;
+		}
+
+		const {value} = node;
+
+		if (
+			typeof value !== 'string'
+			|| value.startsWith('node:')
+			|| !isBuiltinModule(value)
+		) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			data: {moduleName: value},
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => replaceStringLiteral(fixer, node, 'node:', 0, 0),
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer using the `node:` protocol when importing Node.js builtin modules.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/prefer-number-properties.js

@@ -0,0 +1,126 @@
+'use strict';
+const {GlobalReferenceTracker} = require('./utils/global-reference-tracker.js');
+const {replaceReferenceIdentifier} = require('./fix/index.js');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const isLeftHandSide = require('./utils/is-left-hand-side.js');
+
+const MESSAGE_ID_ERROR = 'error';
+const MESSAGE_ID_SUGGESTION = 'suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Prefer `Number.{{property}}` over `{{description}}`.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace `{{description}}` with `Number.{{property}}`.',
+};
+
+const globalObjects = {
+	// Safe to replace with `Number` properties
+	parseInt: true,
+	parseFloat: true,
+	NaN: true,
+	Infinity: true,
+
+	// Unsafe to replace with `Number` properties
+	isNaN: false,
+	isFinite: false,
+};
+
+const isNegative = node => {
+	const {parent} = node;
+	return parent.type === 'UnaryExpression' && parent.operator === '-' && parent.argument === node;
+};
+
+function checkProperty({node, path: [name]}, sourceCode) {
+	const {parent} = node;
+
+	let property = name;
+	if (name === 'Infinity') {
+		property = isNegative(node) ? 'NEGATIVE_INFINITY' : 'POSITIVE_INFINITY';
+	}
+
+	const problem = {
+		node,
+		messageId: MESSAGE_ID_ERROR,
+		data: {
+			description: name,
+			property,
+		},
+	};
+
+	if (property === 'NEGATIVE_INFINITY') {
+		problem.node = parent;
+		problem.data.description = '-Infinity';
+		problem.fix = function * (fixer) {
+			yield fixer.replaceText(parent, 'Number.NEGATIVE_INFINITY');
+			yield * fixSpaceAroundKeyword(fixer, parent, sourceCode);
+		};
+
+		return problem;
+	}
+
+	const fix = fixer => replaceReferenceIdentifier(node, `Number.${property}`, fixer, sourceCode);
+	const isSafeToFix = globalObjects[name];
+
+	if (isSafeToFix) {
+		problem.fix = fix;
+	} else {
+		problem.suggest = [
+			{
+				messageId: MESSAGE_ID_SUGGESTION,
+				fix,
+			},
+		];
+	}
+
+	return problem;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {
+		checkInfinity,
+	} = {
+		checkInfinity: true,
+		...context.options[0],
+	};
+	const {sourceCode} = context;
+
+	let objects = Object.keys(globalObjects);
+	if (!checkInfinity) {
+		objects = objects.filter(name => name !== 'Infinity');
+	}
+
+	const tracker = new GlobalReferenceTracker({
+		objects,
+		handle: reference => checkProperty(reference, sourceCode),
+		filter: ({node}) => !isLeftHandSide(node),
+	});
+
+	return tracker.createListeners(context);
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			checkInfinity: {
+				type: 'boolean',
+				default: true,
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Number` static properties over global ones.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema,
+		messages,
+	},
+};