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

package/rules/prefer-spread.js

@@ -0,0 +1,529 @@
+'use strict';
+const {isParenthesized, getStaticValue, isCommaToken, hasSideEffect} = require('@eslint-community/eslint-utils');
+const {
+	getParenthesizedRange,
+	getParenthesizedText,
+	needsSemicolon,
+	shouldAddParenthesesToSpreadElementArgument,
+	isNodeMatches,
+	isMethodNamed,
+} = require('./utils/index.js');
+const {removeMethodCall} = require('./fix/index.js');
+const {isLiteral, isMethodCall} = require('./ast/index.js');
+
+const ERROR_ARRAY_FROM = 'array-from';
+const ERROR_ARRAY_CONCAT = 'array-concat';
+const ERROR_ARRAY_SLICE = 'array-slice';
+const ERROR_ARRAY_TO_SPLICED = 'array-to-spliced';
+const ERROR_STRING_SPLIT = 'string-split';
+const SUGGESTION_CONCAT_ARGUMENT_IS_SPREADABLE = 'argument-is-spreadable';
+const SUGGESTION_CONCAT_ARGUMENT_IS_NOT_SPREADABLE = 'argument-is-not-spreadable';
+const SUGGESTION_CONCAT_TEST_ARGUMENT = 'test-argument';
+const SUGGESTION_CONCAT_SPREAD_ALL_ARGUMENTS = 'spread-all-arguments';
+const SUGGESTION_USE_SPREAD = 'use-spread';
+const messages = {
+	[ERROR_ARRAY_FROM]: 'Prefer the spread operator over `Array.from(…)`.',
+	[ERROR_ARRAY_CONCAT]: 'Prefer the spread operator over `Array#concat(…)`.',
+	[ERROR_ARRAY_SLICE]: 'Prefer the spread operator over `Array#slice()`.',
+	[ERROR_ARRAY_TO_SPLICED]: 'Prefer the spread operator over `Array#toSpliced()`.',
+	[ERROR_STRING_SPLIT]: 'Prefer the spread operator over `String#split(\'\')`.',
+	[SUGGESTION_CONCAT_ARGUMENT_IS_SPREADABLE]: 'First argument is an `array`.',
+	[SUGGESTION_CONCAT_ARGUMENT_IS_NOT_SPREADABLE]: 'First argument is not an `array`.',
+	[SUGGESTION_CONCAT_TEST_ARGUMENT]: 'Test first argument with `Array.isArray(…)`.',
+	[SUGGESTION_CONCAT_SPREAD_ALL_ARGUMENTS]: 'Spread all unknown arguments`.',
+	[SUGGESTION_USE_SPREAD]: 'Use `...` operator.',
+};
+
+const ignoredSliceCallee = [
+	'arrayBuffer',
+	'blob',
+	'buffer',
+	'file',
+	'this',
+];
+
+const isArrayLiteral = node => node.type === 'ArrayExpression';
+const isArrayLiteralHasTrailingComma = (node, sourceCode) => {
+	if (node.elements.length === 0) {
+		return false;
+	}
+
+	return isCommaToken(sourceCode.getLastToken(node, 1));
+};
+
+function fixConcat(node, sourceCode, fixableArguments) {
+	const array = node.callee.object;
+	const concatCallArguments = node.arguments;
+	const arrayParenthesizedRange = getParenthesizedRange(array, sourceCode);
+	const arrayIsArrayLiteral = isArrayLiteral(array);
+	const arrayHasTrailingComma = arrayIsArrayLiteral && isArrayLiteralHasTrailingComma(array, sourceCode);
+
+	const getArrayLiteralElementsText = (node, keepTrailingComma) => {
+		if (
+			!keepTrailingComma
+			&& isArrayLiteralHasTrailingComma(node, sourceCode)
+		) {
+			const start = node.range[0] + 1;
+			const end = sourceCode.getLastToken(node, 1).range[0];
+			return sourceCode.text.slice(start, end);
+		}
+
+		return sourceCode.getText(node, -1, -1);
+	};
+
+	const getFixedText = () => {
+		const nonEmptyArguments = fixableArguments
+			.filter(({node, isArrayLiteral}) => (!isArrayLiteral || node.elements.length > 0));
+		const lastArgument = nonEmptyArguments.at(-1);
+
+		let text = nonEmptyArguments
+			.map(({node, isArrayLiteral, isSpreadable, testArgument}) => {
+				if (isArrayLiteral) {
+					return getArrayLiteralElementsText(node, node === lastArgument.node);
+				}
+
+				let text = getParenthesizedText(node, sourceCode);
+
+				if (testArgument) {
+					return `...(Array.isArray(${text}) ? ${text} : [${text}])`;
+				}
+
+				if (isSpreadable) {
+					if (
+						!isParenthesized(node, sourceCode)
+						&& shouldAddParenthesesToSpreadElementArgument(node)
+					) {
+						text = `(${text})`;
+					}
+
+					text = `...${text}`;
+				}
+
+				return text || ' ';
+			})
+			.join(', ');
+
+		if (!text) {
+			return '';
+		}
+
+		if (arrayIsArrayLiteral) {
+			if (array.elements.length > 0) {
+				text = ` ${text}`;
+
+				if (!arrayHasTrailingComma) {
+					text = `,${text}`;
+				}
+
+				if (
+					arrayHasTrailingComma
+					&& (!lastArgument.isArrayLiteral || !isArrayLiteralHasTrailingComma(lastArgument.node, sourceCode))
+				) {
+					text = `${text},`;
+				}
+			}
+		} else {
+			text = `, ${text}`;
+		}
+
+		return text;
+	};
+
+	function removeArguments(fixer) {
+		const [firstArgument] = concatCallArguments;
+		const lastArgument = concatCallArguments[fixableArguments.length - 1];
+
+		const [start] = getParenthesizedRange(firstArgument, sourceCode);
+		let [, end] = sourceCode.getTokenAfter(lastArgument, isCommaToken).range;
+
+		const textAfter = sourceCode.text.slice(end);
+		const [leadingSpaces] = textAfter.match(/^\s*/);
+		end += leadingSpaces.length;
+
+		return fixer.replaceTextRange([start, end], '');
+	}
+
+	return function * (fixer) {
+		// Fixed code always starts with `[`
+		if (
+			!arrayIsArrayLiteral
+			&& needsSemicolon(sourceCode.getTokenBefore(node), sourceCode, '[')
+		) {
+			yield fixer.insertTextBefore(node, ';');
+		}
+
+		if (concatCallArguments.length - fixableArguments.length === 0) {
+			yield * removeMethodCall(fixer, node, sourceCode);
+		} else {
+			yield removeArguments(fixer);
+		}
+
+		const text = getFixedText();
+
+		if (arrayIsArrayLiteral) {
+			const closingBracketToken = sourceCode.getLastToken(array);
+			yield fixer.insertTextBefore(closingBracketToken, text);
+		} else {
+			// The array is already accessing `.concat`, there should not any case need add extra `()`
+			yield fixer.insertTextBeforeRange(arrayParenthesizedRange, '[...');
+			yield fixer.insertTextAfterRange(arrayParenthesizedRange, text);
+			yield fixer.insertTextAfterRange(arrayParenthesizedRange, ']');
+		}
+	};
+}
+
+const getConcatArgumentSpreadable = (node, scope) => {
+	if (node.type === 'SpreadElement') {
+		return;
+	}
+
+	if (isArrayLiteral(node)) {
+		return {node, isArrayLiteral: true};
+	}
+
+	const result = getStaticValue(node, scope);
+
+	if (!result) {
+		return;
+	}
+
+	const isSpreadable = Array.isArray(result.value);
+
+	return {node, isSpreadable};
+};
+
+function getConcatFixableArguments(argumentsList, scope) {
+	const fixableArguments = [];
+
+	for (const node of argumentsList) {
+		const result = getConcatArgumentSpreadable(node, scope);
+
+		if (result) {
+			fixableArguments.push(result);
+		} else {
+			break;
+		}
+	}
+
+	return fixableArguments;
+}
+
+function fixArrayFrom(node, sourceCode) {
+	const [object] = node.arguments;
+
+	function getObjectText() {
+		if (isArrayLiteral(object)) {
+			return sourceCode.getText(object);
+		}
+
+		const [start, end] = getParenthesizedRange(object, sourceCode);
+		let text = sourceCode.text.slice(start, end);
+
+		if (
+			!isParenthesized(object, sourceCode)
+			&& shouldAddParenthesesToSpreadElementArgument(object)
+		) {
+			text = `(${text})`;
+		}
+
+		return `[...${text}]`;
+	}
+
+	return function * (fixer) {
+		// Fixed code always starts with `[`
+		if (needsSemicolon(sourceCode.getTokenBefore(node), sourceCode, '[')) {
+			yield fixer.insertTextBefore(node, ';');
+		}
+
+		const objectText = getObjectText();
+
+		yield fixer.replaceText(node, objectText);
+	};
+}
+
+function methodCallToSpread(node, sourceCode) {
+	return function * (fixer) {
+		// Fixed code always starts with `[`
+		if (needsSemicolon(sourceCode.getTokenBefore(node), sourceCode, '[')) {
+			yield fixer.insertTextBefore(node, ';');
+		}
+
+		yield fixer.insertTextBefore(node, '[...');
+		yield fixer.insertTextAfter(node, ']');
+
+		// The array is already accessing `.slice` or `.split`, there should not any case need add extra `()`
+
+		yield * removeMethodCall(fixer, node, sourceCode);
+	};
+}
+
+function isClassName(node) {
+	if (node.type === 'MemberExpression') {
+		node = node.property;
+	}
+
+	if (node.type !== 'Identifier') {
+		return false;
+	}
+
+	const {name} = node;
+
+	return /^[A-Z]./.test(name) && name.toUpperCase() !== name;
+}
+
+function isNotArray(node, scope) {
+	if (
+		node.type === 'TemplateLiteral'
+		|| node.type === 'Literal'
+		|| node.type === 'BinaryExpression'
+		|| isClassName(node)
+		// `foo.join()`
+		|| (isMethodNamed(node, 'join') && node.arguments.length <= 1)
+	) {
+		return true;
+	}
+
+	const staticValue = getStaticValue(node, scope);
+	if (staticValue && !Array.isArray(staticValue.value)) {
+		return true;
+	}
+
+	return false;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	// `Array.from()`
+	context.on('CallExpression', node => {
+		if (
+			isMethodCall(node, {
+				object: 'Array',
+				method: 'from',
+				argumentsLength: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// Allow `Array.from({length})`
+			&& node.arguments[0].type !== 'ObjectExpression'
+		) {
+			return {
+				node,
+				messageId: ERROR_ARRAY_FROM,
+				fix: fixArrayFrom(node, sourceCode),
+			};
+		}
+	});
+
+	// `array.concat()`
+	context.on('CallExpression', node => {
+		if (!isMethodCall(node, {
+			method: 'concat',
+			optionalCall: false,
+			optionalMember: false,
+		})) {
+			return;
+		}
+
+		const {object} = node.callee;
+		const scope = sourceCode.getScope(object);
+
+		if (isNotArray(object, scope)) {
+			return;
+		}
+
+		const staticResult = getStaticValue(object, scope);
+		if (staticResult && !Array.isArray(staticResult.value)) {
+			return;
+		}
+
+		const problem = {
+			node: node.callee.property,
+			messageId: ERROR_ARRAY_CONCAT,
+		};
+
+		const fixableArguments = getConcatFixableArguments(node.arguments, scope);
+
+		if (fixableArguments.length > 0 || node.arguments.length === 0) {
+			problem.fix = fixConcat(node, sourceCode, fixableArguments);
+			return problem;
+		}
+
+		const [firstArgument, ...restArguments] = node.arguments;
+		if (firstArgument.type === 'SpreadElement') {
+			return problem;
+		}
+
+		const fixableArgumentsAfterFirstArgument = getConcatFixableArguments(restArguments, scope);
+		const suggestions = [
+			{
+				messageId: SUGGESTION_CONCAT_ARGUMENT_IS_SPREADABLE,
+				isSpreadable: true,
+			},
+			{
+				messageId: SUGGESTION_CONCAT_ARGUMENT_IS_NOT_SPREADABLE,
+				isSpreadable: false,
+			},
+		];
+
+		if (!hasSideEffect(firstArgument, sourceCode)) {
+			suggestions.push({
+				messageId: SUGGESTION_CONCAT_TEST_ARGUMENT,
+				testArgument: true,
+			});
+		}
+
+		problem.suggest = suggestions.map(({messageId, isSpreadable, testArgument}) => ({
+			messageId,
+			fix: fixConcat(
+				node,
+				sourceCode,
+				// When apply suggestion, we also merge fixable arguments after the first one
+				[
+					{
+						node: firstArgument,
+						isSpreadable,
+						testArgument,
+					},
+					...fixableArgumentsAfterFirstArgument,
+				],
+			),
+		}));
+
+		if (
+			fixableArgumentsAfterFirstArgument.length < restArguments.length
+			&& restArguments.every(({type}) => type !== 'SpreadElement')
+		) {
+			problem.suggest.push({
+				messageId: SUGGESTION_CONCAT_SPREAD_ALL_ARGUMENTS,
+				fix: fixConcat(
+					node,
+					sourceCode,
+					node.arguments.map(node => getConcatArgumentSpreadable(node, scope) || {node, isSpreadable: true}),
+				),
+			});
+		}
+
+		return problem;
+	});
+
+	// `array.slice()`
+	context.on('CallExpression', node => {
+		if (!(
+			isMethodCall(node, {
+				method: 'slice',
+				minimumArguments: 0,
+				maximumArguments: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& node.callee.object.type !== 'ArrayExpression'
+		)) {
+			return;
+		}
+
+		if (isNodeMatches(node.callee.object, ignoredSliceCallee)) {
+			return;
+		}
+
+		const [firstArgument] = node.arguments;
+		if (firstArgument && !isLiteral(firstArgument, 0)) {
+			return;
+		}
+
+		return {
+			node: node.callee.property,
+			messageId: ERROR_ARRAY_SLICE,
+			fix: methodCallToSpread(node, sourceCode),
+		};
+	});
+
+	// `array.toSpliced()`
+	context.on('CallExpression', node => {
+		if (!(
+			isMethodCall(node, {
+				method: 'toSpliced',
+				argumentsLength: 0,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& node.callee.object.type !== 'ArrayExpression'
+		)) {
+			return;
+		}
+
+		return {
+			node: node.callee.property,
+			messageId: ERROR_ARRAY_TO_SPLICED,
+			fix: methodCallToSpread(node, sourceCode),
+		};
+	});
+
+	// `string.split()`
+	context.on('CallExpression', node => {
+		if (!isMethodCall(node, {
+			method: 'split',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})) {
+			return;
+		}
+
+		const [separator] = node.arguments;
+		if (!isLiteral(separator, '')) {
+			return;
+		}
+
+		const string = node.callee.object;
+		const staticValue = getStaticValue(string, sourceCode.getScope(string));
+		let hasSameResult = false;
+		if (staticValue) {
+			const {value} = staticValue;
+
+			if (typeof value !== 'string') {
+				return;
+			}
+
+			// eslint-disable-next-line unicorn/prefer-spread
+			const resultBySplit = value.split('');
+			const resultBySpread = [...value];
+
+			hasSameResult = resultBySplit.length === resultBySpread.length
+					&& resultBySplit.every((character, index) => character === resultBySpread[index]);
+		}
+
+		const problem = {
+			node: node.callee.property,
+			messageId: ERROR_STRING_SPLIT,
+		};
+
+		if (hasSameResult) {
+			problem.fix = methodCallToSpread(node, sourceCode);
+		} else {
+			problem.suggest = [
+				{
+					messageId: SUGGESTION_USE_SPREAD,
+					fix: methodCallToSpread(node, sourceCode),
+				},
+			];
+		}
+
+		return problem;
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer the spread operator over `Array.from(…)`, `Array#concat(…)`, `Array#{slice,toSpliced}()` and `String#split(\'\')`.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-string-replace-all.js

@@ -0,0 +1,145 @@
+'use strict';
+const {getStaticValue} = require('@eslint-community/eslint-utils');
+const {parse: parseRegExp} = require('regjsparser');
+const escapeString = require('./utils/escape-string.js');
+const {isRegexLiteral, isNewExpression, isMethodCall} = require('./ast/index.js');
+
+const MESSAGE_ID_USE_REPLACE_ALL = 'method';
+const MESSAGE_ID_USE_STRING = 'pattern';
+const messages = {
+	[MESSAGE_ID_USE_REPLACE_ALL]: 'Prefer `String#replaceAll()` over `String#replace()`.',
+	[MESSAGE_ID_USE_STRING]: 'This pattern can be replaced with {{replacement}}.',
+};
+
+function getPatternReplacement(node) {
+	if (!isRegexLiteral(node)) {
+		return;
+	}
+
+	const {pattern, flags} = node.regex;
+	if (flags.replace('u', '').replace('v', '') !== 'g') {
+		return;
+	}
+
+	let tree;
+
+	try {
+		tree = parseRegExp(pattern, flags, {
+			unicodePropertyEscape: flags.includes('u'),
+			unicodeSet: flags.includes('v'),
+			namedGroups: true,
+			lookbehind: true,
+		});
+	} catch {
+		return;
+	}
+
+	const parts = tree.type === 'alternative' ? tree.body : [tree];
+	if (parts.some(part => part.type !== 'value')) {
+		return;
+	}
+
+	// TODO: Preserve escape
+	const string = String.fromCodePoint(...parts.map(part => part.codePoint));
+
+	return escapeString(string);
+}
+
+const isRegExpWithGlobalFlag = (node, scope) => {
+	if (isRegexLiteral(node)) {
+		return node.regex.flags.includes('g');
+	}
+
+	if (
+		isNewExpression(node, {name: 'RegExp'})
+		&& node.arguments[0]?.type !== 'SpreadElement'
+		&& node.arguments[1]?.type === 'Literal'
+		&& typeof node.arguments[1].value === 'string'
+	) {
+		return node.arguments[1].value.includes('g');
+	}
+
+	const staticResult = getStaticValue(node, scope);
+
+	// Don't know if there is `g` flag
+	if (!staticResult) {
+		return false;
+	}
+
+	const {value} = staticResult;
+	return (
+		Object.prototype.toString.call(value) === '[object RegExp]'
+		&& value.global
+	);
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(node) {
+		if (!isMethodCall(node, {
+			methods: ['replace', 'replaceAll'],
+			argumentsLength: 2,
+			optionalCall: false,
+			optionalMember: false,
+		})) {
+			return;
+		}
+
+		const {
+			arguments: [pattern],
+			callee: {property},
+		} = node;
+
+		if (!isRegExpWithGlobalFlag(pattern, context.sourceCode.getScope(pattern))) {
+			return;
+		}
+
+		const methodName = property.name;
+		const patternReplacement = getPatternReplacement(pattern);
+
+		if (methodName === 'replaceAll') {
+			if (!patternReplacement) {
+				return;
+			}
+
+			return {
+				node: pattern,
+				messageId: MESSAGE_ID_USE_STRING,
+				data: {
+					// Show `This pattern can be replaced with a string literal.` for long strings
+					replacement: patternReplacement.length < 20 ? patternReplacement : 'a string literal',
+				},
+				/** @param {import('eslint').Rule.RuleFixer} fixer */
+				fix: fixer => fixer.replaceText(pattern, patternReplacement),
+			};
+		}
+
+		return {
+			node: property,
+			messageId: MESSAGE_ID_USE_REPLACE_ALL,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			* fix(fixer) {
+				yield fixer.insertTextAfter(property, 'All');
+
+				if (!patternReplacement) {
+					return;
+				}
+
+				yield fixer.replaceText(pattern, patternReplacement);
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `String#replaceAll()` over regex searches with the global flag.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};