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

package/rules/prefer-regexp-test.js

@@ -0,0 +1,156 @@
+'use strict';
+const {isParenthesized, getStaticValue} = require('@eslint-community/eslint-utils');
+const {checkVueTemplate} = require('./utils/rule.js');
+const {isRegexLiteral, isNewExpression, isMethodCall} = require('./ast/index.js');
+const {
+	isBooleanNode,
+	shouldAddParenthesesToMemberExpressionObject,
+} = require('./utils/index.js');
+
+const REGEXP_EXEC = 'regexp-exec';
+const STRING_MATCH = 'string-match';
+const SUGGESTION = 'suggestion';
+const messages = {
+	[REGEXP_EXEC]: 'Prefer `.test(…)` over `.exec(…)`.',
+	[STRING_MATCH]: 'Prefer `RegExp#test(…)` over `String#match(…)`.',
+	[SUGGESTION]: 'Switch to `RegExp#test(…)`.',
+};
+
+const cases = [
+	{
+		type: REGEXP_EXEC,
+		test: node => isMethodCall(node, {
+			method: 'exec',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		}),
+		getNodes: node => ({
+			stringNode: node.arguments[0],
+			methodNode: node.callee.property,
+			regexpNode: node.callee.object,
+		}),
+		fix: (fixer, {methodNode}) => fixer.replaceText(methodNode, 'test'),
+	},
+	{
+		type: STRING_MATCH,
+		test: node => isMethodCall(node, {
+			method: 'match',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		}),
+		getNodes: node => ({
+			stringNode: node.callee.object,
+			methodNode: node.callee.property,
+			regexpNode: node.arguments[0],
+		}),
+		* fix(fixer, {stringNode, methodNode, regexpNode}, sourceCode) {
+			yield fixer.replaceText(methodNode, 'test');
+
+			let stringText = sourceCode.getText(stringNode);
+			if (
+				!isParenthesized(regexpNode, sourceCode)
+				// Only `SequenceExpression` need add parentheses
+				&& stringNode.type === 'SequenceExpression'
+			) {
+				stringText = `(${stringText})`;
+			}
+
+			yield fixer.replaceText(regexpNode, stringText);
+
+			let regexpText = sourceCode.getText(regexpNode);
+			if (
+				!isParenthesized(stringNode, sourceCode)
+				&& shouldAddParenthesesToMemberExpressionObject(regexpNode, sourceCode)
+			) {
+				regexpText = `(${regexpText})`;
+			}
+
+			// The nodes that pass `isBooleanNode` cannot have an ASI problem.
+
+			yield fixer.replaceText(stringNode, regexpText);
+		},
+	},
+];
+
+const isRegExpNode = node => isRegexLiteral(node) || isNewExpression(node, {name: 'RegExp'});
+
+const isRegExpWithoutGlobalFlag = (node, scope) => {
+	if (isRegexLiteral(node)) {
+		return !node.regex.flags.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 (!isBooleanNode(node)) {
+			return;
+		}
+
+		for (const {type, test, getNodes, fix} of cases) {
+			if (!test(node)) {
+				continue;
+			}
+
+			const nodes = getNodes(node);
+			const {methodNode, regexpNode} = nodes;
+
+			if (regexpNode.type === 'Literal' && !regexpNode.regex) {
+				continue;
+			}
+
+			const problem = {
+				node: type === REGEXP_EXEC ? methodNode : node,
+				messageId: type,
+			};
+
+			const {sourceCode} = context;
+			const fixFunction = fixer => fix(fixer, nodes, sourceCode);
+
+			if (
+				isRegExpNode(regexpNode)
+				|| isRegExpWithoutGlobalFlag(regexpNode, sourceCode.getScope(regexpNode))
+			) {
+				problem.fix = fixFunction;
+			} else {
+				problem.suggest = [
+					{
+						messageId: SUGGESTION,
+						fix: fixFunction,
+					},
+				];
+			}
+
+			yield problem;
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create: checkVueTemplate(create),
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `RegExp#test()` over `String#match()` and `RegExp#exec()`.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-set-has.js

@@ -0,0 +1,186 @@
+'use strict';
+const {findVariable} = require('@eslint-community/eslint-utils');
+const {getVariableIdentifiers} = require('./utils/index.js');
+const {isCallOrNewExpression, isMethodCall} = require('./ast/index.js');
+
+const MESSAGE_ID_ERROR = 'error';
+const MESSAGE_ID_SUGGESTION = 'suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: '`{{name}}` should be a `Set`, and use `{{name}}.has()` to check existence or non-existence.',
+	[MESSAGE_ID_SUGGESTION]: 'Switch `{{name}}` to `Set`.',
+};
+
+const arrayMethodsReturnsArray = [
+	'concat',
+	'copyWithin',
+	'fill',
+	'filter',
+	'flat',
+	'flatMap',
+	'map',
+	'reverse',
+	'slice',
+	'sort',
+	'splice',
+	'toReversed',
+	'toSorted',
+	'toSpliced',
+	'with',
+];
+
+const isIncludesCall = node => {
+	const {type, optional, callee, arguments: includesArguments} = node.parent.parent ?? {};
+	return (
+		type === 'CallExpression'
+		&& !optional
+		&& callee.type === 'MemberExpression'
+		&& !callee.computed
+		&& !callee.optional
+		&& callee.object === node
+		&& callee.property.type === 'Identifier'
+		&& callee.property.name === 'includes'
+		&& includesArguments.length === 1
+		&& includesArguments[0].type !== 'SpreadElement'
+	);
+};
+
+const multipleCallNodeTypes = new Set([
+	'ForOfStatement',
+	'ForStatement',
+	'ForInStatement',
+	'WhileStatement',
+	'DoWhileStatement',
+	'FunctionDeclaration',
+	'FunctionExpression',
+	'ArrowFunctionExpression',
+]);
+
+const isMultipleCall = (identifier, node) => {
+	const root = node.parent.parent.parent;
+	let {parent} = identifier.parent; // `.include()` callExpression
+	while (
+		parent
+		&& parent !== root
+	) {
+		if (multipleCallNodeTypes.has(parent.type)) {
+			return true;
+		}
+
+		parent = parent.parent;
+	}
+
+	return false;
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	Identifier(node) {
+		const {parent} = node;
+
+		if (!(
+			parent.type === 'VariableDeclarator'
+			&& parent.id === node
+			&& Boolean(parent.init)
+			&& parent.parent.type === 'VariableDeclaration'
+			&& parent.parent.declarations.includes(parent)
+			// Exclude `export const foo = [];`
+			&& !(
+				parent.parent.parent.type === 'ExportNamedDeclaration'
+				&& parent.parent.parent.declaration === parent.parent
+			)
+			&& (
+				// `[]`
+				parent.init.type === 'ArrayExpression'
+				// `Array()` and `new Array()`
+				|| isCallOrNewExpression(parent.init, {
+					name: 'Array',
+					optional: false,
+				})
+				// `Array.from()` and `Array.of()`
+				|| isMethodCall(parent.init, {
+					object: 'Array',
+					methods: ['from', 'of'],
+					optionalCall: false,
+					optionalMember: false,
+				})
+				// Array methods that return an array
+				|| isMethodCall(parent.init, {
+					methods: arrayMethodsReturnsArray,
+					optionalCall: false,
+					optionalMember: false,
+				})
+			)
+		)) {
+			return;
+		}
+
+		const variable = findVariable(context.sourceCode.getScope(node), node);
+
+		// This was reported https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1075#issuecomment-768073342
+		// But can't reproduce, just ignore this case
+		/* c8 ignore next 3 */
+		if (!variable) {
+			return;
+		}
+
+		const identifiers = getVariableIdentifiers(variable).filter(identifier => identifier !== node);
+
+		if (
+			identifiers.length === 0
+			|| identifiers.some(identifier => !isIncludesCall(identifier))
+		) {
+			return;
+		}
+
+		if (
+			identifiers.length === 1
+			&& identifiers.every(identifier => !isMultipleCall(identifier, node))
+		) {
+			return;
+		}
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				name: node.name,
+			},
+		};
+
+		const fix = function * (fixer) {
+			yield fixer.insertTextBefore(node.parent.init, 'new Set(');
+			yield fixer.insertTextAfter(node.parent.init, ')');
+
+			for (const identifier of identifiers) {
+				yield fixer.replaceText(identifier.parent.property, 'has');
+			}
+		};
+
+		if (node.typeAnnotation) {
+			problem.suggest = [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					fix,
+				},
+			];
+		} else {
+			problem.fix = fix;
+		}
+
+		return problem;
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-set-size.js

@@ -0,0 +1,103 @@
+'use strict';
+const {findVariable} = require('@eslint-community/eslint-utils');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const {isNewExpression, isMemberExpression} = require('./ast/index.js');
+
+const MESSAGE_ID = 'prefer-set-size';
+const messages = {
+	[MESSAGE_ID]: 'Prefer using `Set#size` instead of `Array#length`.',
+};
+
+const isNewSet = node => isNewExpression(node, {name: 'Set'});
+
+function isSet(node, scope) {
+	if (isNewSet(node)) {
+		return true;
+	}
+
+	if (node.type !== 'Identifier') {
+		return false;
+	}
+
+	const variable = findVariable(scope, node);
+
+	if (!variable || variable.defs.length !== 1) {
+		return false;
+	}
+
+	const [definition] = variable.defs;
+
+	if (definition.type !== 'Variable' || definition.kind !== 'const') {
+		return false;
+	}
+
+	const declarator = definition.node;
+	return declarator.type === 'VariableDeclarator'
+		&& declarator.id.type === 'Identifier'
+		&& isNewSet(definition.node.init);
+}
+
+// `[...set].length` -> `set.size`
+function fix(sourceCode, lengthAccessNodes) {
+	const {
+		object: arrayExpression,
+		property,
+	} = lengthAccessNodes;
+	const set = arrayExpression.elements[0].argument;
+
+	if (sourceCode.getCommentsInside(arrayExpression).length > sourceCode.getCommentsInside(set).length) {
+		return;
+	}
+
+	/** @param {import('eslint').Rule.RuleFixer} fixer */
+	return function * (fixer) {
+		yield fixer.replaceText(property, 'size');
+		yield fixer.replaceText(arrayExpression, sourceCode.getText(set));
+		yield * fixSpaceAroundKeyword(fixer, lengthAccessNodes, sourceCode);
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		MemberExpression(node) {
+			if (
+				!isMemberExpression(node, {
+					property: 'length',
+					optional: false,
+				})
+				|| node.object.type !== 'ArrayExpression'
+				|| node.object.elements.length !== 1
+				|| node.object.elements[0]?.type !== 'SpreadElement'
+			) {
+				return;
+			}
+
+			const maybeSet = node.object.elements[0].argument;
+			if (!isSet(maybeSet, sourceCode.getScope(maybeSet))) {
+				return;
+			}
+
+			return {
+				node: node.property,
+				messageId: MESSAGE_ID,
+				fix: fix(sourceCode, node),
+			};
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer using `Set#size` instead of `Array#length`.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};