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

package/rules/prefer-switch.js

@@ -0,0 +1,344 @@
+'use strict';
+const {hasSideEffect} = require('@eslint-community/eslint-utils');
+const isSameReference = require('./utils/is-same-reference.js');
+const getIndentString = require('./utils/get-indent-string.js');
+
+const MESSAGE_ID = 'prefer-switch';
+const messages = {
+	[MESSAGE_ID]: 'Use `switch` instead of multiple `else-if`.',
+};
+
+const isSame = (nodeA, nodeB) => nodeA === nodeB || isSameReference(nodeA, nodeB);
+
+function getEqualityComparisons(node) {
+	const nodes = [node];
+	const compareExpressions = [];
+	while (nodes.length > 0) {
+		node = nodes.pop();
+
+		if (node.type === 'LogicalExpression' && node.operator === '||') {
+			nodes.push(node.right, node.left);
+			continue;
+		}
+
+		if (node.type !== 'BinaryExpression' || node.operator !== '===') {
+			return [];
+		}
+
+		compareExpressions.push(node);
+	}
+
+	return compareExpressions;
+}
+
+function getCommonReferences(expressions, candidates) {
+	for (const {left, right} of expressions) {
+		candidates = candidates.filter(node => isSame(node, left) || isSame(node, right));
+
+		if (candidates.length === 0) {
+			break;
+		}
+	}
+
+	return candidates;
+}
+
+function getStatements(statement) {
+	let discriminantCandidates;
+	const ifStatements = [];
+	for (; statement && statement.type === 'IfStatement'; statement = statement.alternate) {
+		const {test} = statement;
+		const compareExpressions = getEqualityComparisons(test);
+
+		if (compareExpressions.length === 0) {
+			break;
+		}
+
+		if (!discriminantCandidates) {
+			const [{left, right}] = compareExpressions;
+			discriminantCandidates = [left, right];
+		}
+
+		const candidates = getCommonReferences(
+			compareExpressions,
+			discriminantCandidates,
+		);
+
+		if (candidates.length === 0) {
+			break;
+		}
+
+		discriminantCandidates = candidates;
+
+		ifStatements.push({
+			statement,
+			compareExpressions,
+		});
+	}
+
+	return {
+		ifStatements,
+		discriminant: discriminantCandidates && discriminantCandidates[0],
+	};
+}
+
+const breakAbleNodeTypes = new Set([
+	'WhileStatement',
+	'DoWhileStatement',
+	'ForStatement',
+	'ForOfStatement',
+	'ForInStatement',
+	'SwitchStatement',
+]);
+const getBreakTarget = node => {
+	for (;node.parent; node = node.parent) {
+		if (breakAbleNodeTypes.has(node.type)) {
+			return node;
+		}
+	}
+};
+
+const isNodeInsideNode = (inner, outer) =>
+	inner.range[0] >= outer.range[0] && inner.range[1] <= outer.range[1];
+function hasBreakInside(breakStatements, node) {
+	for (const breakStatement of breakStatements) {
+		if (!isNodeInsideNode(breakStatement, node)) {
+			continue;
+		}
+
+		const breakTarget = getBreakTarget(breakStatement);
+
+		if (!breakTarget) {
+			return true;
+		}
+
+		if (isNodeInsideNode(node, breakTarget)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function * insertBracesIfNotBlockStatement(node, fixer, indent) {
+	if (!node || node.type === 'BlockStatement') {
+		return;
+	}
+
+	yield fixer.insertTextBefore(node, `{\n${indent}`);
+	yield fixer.insertTextAfter(node, `\n${indent}}`);
+}
+
+function * insertBreakStatement(node, fixer, sourceCode, indent) {
+	if (node.type === 'BlockStatement') {
+		const lastToken = sourceCode.getLastToken(node);
+		yield fixer.insertTextBefore(lastToken, `\n${indent}break;\n${indent}`);
+	} else {
+		yield fixer.insertTextAfter(node, `\n${indent}break;`);
+	}
+}
+
+function getBlockStatementLastNode(blockStatement) {
+	const {body} = blockStatement;
+	for (let index = body.length - 1; index >= 0; index--) {
+		const node = body[index];
+		if (node.type === 'FunctionDeclaration' || node.type === 'EmptyStatement') {
+			continue;
+		}
+
+		if (node.type === 'BlockStatement') {
+			const last = getBlockStatementLastNode(node);
+			if (last) {
+				return last;
+			}
+
+			continue;
+		}
+
+		return node;
+	}
+}
+
+function shouldInsertBreakStatement(node) {
+	switch (node.type) {
+		case 'ReturnStatement':
+		case 'ThrowStatement': {
+			return false;
+		}
+
+		case 'IfStatement': {
+			return !node.alternate
+				|| shouldInsertBreakStatement(node.consequent)
+				|| shouldInsertBreakStatement(node.alternate);
+		}
+
+		case 'BlockStatement': {
+			const lastNode = getBlockStatementLastNode(node);
+			return !lastNode || shouldInsertBreakStatement(lastNode);
+		}
+
+		default: {
+			return true;
+		}
+	}
+}
+
+function fix({discriminant, ifStatements}, sourceCode, options) {
+	const discriminantText = sourceCode.getText(discriminant);
+
+	return function * (fixer) {
+		const firstStatement = ifStatements[0].statement;
+		const indent = getIndentString(firstStatement, sourceCode);
+		yield fixer.insertTextBefore(firstStatement, `switch (${discriminantText}) {`);
+
+		const lastStatement = ifStatements.at(-1).statement;
+		if (lastStatement.alternate) {
+			const {alternate} = lastStatement;
+			yield fixer.insertTextBefore(alternate, `\n${indent}default: `);
+			/*
+			Technically, we should insert braces for the following case,
+			but who writes like this? And using `let`/`const` is invalid.
+
+			```js
+			if (foo === 1) {}
+			else if (foo === 2) {}
+			else if (foo === 3) {}
+			else var a = 1;
+			```
+			*/
+		} else {
+			switch (options.emptyDefaultCase) {
+				case 'no-default-comment': {
+					yield fixer.insertTextAfter(firstStatement, `\n${indent}// No default`);
+					break;
+				}
+
+				case 'do-nothing-comment': {
+					yield fixer.insertTextAfter(firstStatement, `\n${indent}default:\n${indent}// Do nothing`);
+					break;
+				}
+				// No default
+			}
+		}
+
+		yield fixer.insertTextAfter(firstStatement, `\n${indent}}`);
+
+		for (const {statement, compareExpressions} of ifStatements) {
+			const {consequent, alternate, range} = statement;
+			const headRange = [range[0], consequent.range[0]];
+
+			if (alternate) {
+				const [, start] = consequent.range;
+				const [end] = alternate.range;
+				yield fixer.replaceTextRange([start, end], '');
+			}
+
+			yield fixer.replaceTextRange(headRange, '');
+			for (const {left, right} of compareExpressions) {
+				const node = isSame(left, discriminant) ? right : left;
+				const text = sourceCode.getText(node);
+				yield fixer.insertTextBefore(consequent, `\n${indent}case ${text}: `);
+			}
+
+			if (shouldInsertBreakStatement(consequent)) {
+				yield * insertBreakStatement(consequent, fixer, sourceCode, indent);
+				yield * insertBracesIfNotBlockStatement(consequent, fixer, indent);
+			}
+		}
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const options = {
+		minimumCases: 3,
+		emptyDefaultCase: 'no-default-comment',
+		insertBreakInDefaultCase: false,
+		...context.options[0],
+	};
+	const {sourceCode} = context;
+	const ifStatements = new Set();
+	const breakStatements = [];
+	const checked = new Set();
+
+	return {
+		IfStatement(node) {
+			ifStatements.add(node);
+		},
+		BreakStatement(node) {
+			if (!node.label) {
+				breakStatements.push(node);
+			}
+		},
+		* 'Program:exit'() {
+			for (const node of ifStatements) {
+				if (checked.has(node)) {
+					continue;
+				}
+
+				const {discriminant, ifStatements} = getStatements(node);
+
+				if (!discriminant || ifStatements.length < options.minimumCases) {
+					continue;
+				}
+
+				for (const {statement} of ifStatements) {
+					checked.add(statement);
+				}
+
+				const problem = {
+					loc: {
+						start: node.loc.start,
+						end: node.consequent.loc.start,
+					},
+					messageId: MESSAGE_ID,
+				};
+
+				if (
+					!hasSideEffect(discriminant, sourceCode)
+					&& !ifStatements.some(({statement}) => hasBreakInside(breakStatements, statement))
+				) {
+					problem.fix = fix({discriminant, ifStatements}, sourceCode, options);
+				}
+
+				yield problem;
+			}
+		},
+	};
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			minimumCases: {
+				type: 'integer',
+				minimum: 2,
+				default: 3,
+			},
+			emptyDefaultCase: {
+				enum: [
+					'no-default-comment',
+					'do-nothing-comment',
+					'no-default-case',
+				],
+				default: 'no-default-comment',
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `switch` over multiple `else-if`.',
+		},
+		fixable: 'code',
+		schema,
+		messages,
+	},
+};

package/rules/prefer-ternary.js

@@ -0,0 +1,282 @@
+'use strict';
+const {isParenthesized} = require('@eslint-community/eslint-utils');
+const avoidCapture = require('./utils/avoid-capture.js');
+const needsSemicolon = require('./utils/needs-semicolon.js');
+const isSameReference = require('./utils/is-same-reference.js');
+const getIndentString = require('./utils/get-indent-string.js');
+const {getParenthesizedText} = require('./utils/parentheses.js');
+const shouldAddParenthesesToConditionalExpressionChild = require('./utils/should-add-parentheses-to-conditional-expression-child.js');
+const {extendFixRange} = require('./fix/index.js');
+const getScopes = require('./utils/get-scopes.js');
+
+const messageId = 'prefer-ternary';
+
+const isTernary = node => node?.type === 'ConditionalExpression';
+
+function getNodeBody(node) {
+	/* c8 ignore next 3 */
+	if (!node) {
+		return;
+	}
+
+	if (node.type === 'ExpressionStatement') {
+		return getNodeBody(node.expression);
+	}
+
+	if (node.type === 'BlockStatement') {
+		const body = node.body.filter(({type}) => type !== 'EmptyStatement');
+		if (body.length === 1) {
+			return getNodeBody(body[0]);
+		}
+	}
+
+	return node;
+}
+
+const isSingleLineNode = node => node.loc.start.line === node.loc.end.line;
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const onlySingleLine = context.options[0] === 'only-single-line';
+	const {sourceCode} = context;
+	const scopeToNamesGeneratedByFixer = new WeakMap();
+	const isSafeName = (name, scopes) => scopes.every(scope => {
+		const generatedNames = scopeToNamesGeneratedByFixer.get(scope);
+		return !generatedNames || !generatedNames.has(name);
+	});
+
+	const getText = node => {
+		let text = getParenthesizedText(node, sourceCode);
+		if (
+			!isParenthesized(node, sourceCode)
+			&& shouldAddParenthesesToConditionalExpressionChild(node)
+		) {
+			text = `(${text})`;
+		}
+
+		return text;
+	};
+
+	function merge(options, mergeOptions) {
+		const {
+			before = '',
+			after = ';',
+			consequent,
+			alternate,
+			node,
+		} = options;
+
+		const {
+			checkThrowStatement,
+			returnFalseIfNotMergeable,
+		} = {
+			checkThrowStatement: false,
+			returnFalseIfNotMergeable: false,
+			...mergeOptions,
+		};
+
+		if (!consequent || !alternate || consequent.type !== alternate.type) {
+			return returnFalseIfNotMergeable ? false : options;
+		}
+
+		const {type, argument, delegate, left, right, operator} = consequent;
+
+		if (
+			type === 'ReturnStatement'
+			&& !isTernary(argument)
+			&& !isTernary(alternate.argument)
+		) {
+			return merge({
+				before: `${before}return `,
+				after,
+				consequent: argument === null ? 'undefined' : argument,
+				alternate: alternate.argument === null ? 'undefined' : alternate.argument,
+				node,
+			});
+		}
+
+		if (
+			type === 'YieldExpression'
+			&& delegate === alternate.delegate
+			&& !isTernary(argument)
+			&& !isTernary(alternate.argument)
+		) {
+			return merge({
+				before: `${before}yield${delegate ? '*' : ''} (`,
+				after: `)${after}`,
+				consequent: argument === null ? 'undefined' : argument,
+				alternate: alternate.argument === null ? 'undefined' : alternate.argument,
+				node,
+			});
+		}
+
+		if (
+			type === 'AwaitExpression'
+			&& !isTernary(argument)
+			&& !isTernary(alternate.argument)
+		) {
+			return merge({
+				before: `${before}await (`,
+				after: `)${after}`,
+				consequent: argument,
+				alternate: alternate.argument,
+				node,
+			});
+		}
+
+		if (
+			checkThrowStatement
+			&& type === 'ThrowStatement'
+			&& !isTernary(argument)
+			&& !isTernary(alternate.argument)
+		) {
+			// `ThrowStatement` don't check nested
+
+			// If `IfStatement` is not a `BlockStatement`, need add `{}`
+			const {parent} = node;
+			const needBraces = parent && parent.type !== 'BlockStatement';
+			return {
+				type,
+				before: `${before}${needBraces ? '{\n{{INDENT_STRING}}' : ''}const {{ERROR_NAME}} = `,
+				after: `;\n{{INDENT_STRING}}throw {{ERROR_NAME}};${needBraces ? '\n}' : ''}`,
+				consequent: argument,
+				alternate: alternate.argument,
+			};
+		}
+
+		if (
+			type === 'AssignmentExpression'
+			&& operator === alternate.operator
+			&& !isTernary(left)
+			&& !isTernary(alternate.left)
+			&& !isTernary(right)
+			&& !isTernary(alternate.right)
+			&& isSameReference(left, alternate.left)
+		) {
+			return merge({
+				before: `${before}${sourceCode.getText(left)} ${operator} `,
+				after,
+				consequent: right,
+				alternate: alternate.right,
+				node,
+			});
+		}
+
+		return returnFalseIfNotMergeable ? false : options;
+	}
+
+	return {
+		IfStatement(node) {
+			if (
+				(node.parent.type === 'IfStatement' && node.parent.alternate === node)
+				|| node.test.type === 'ConditionalExpression'
+				|| !node.consequent
+				|| !node.alternate
+			) {
+				return;
+			}
+
+			const consequent = getNodeBody(node.consequent);
+			const alternate = getNodeBody(node.alternate);
+
+			if (
+				onlySingleLine
+				&& [consequent, alternate, node.test].some(node => !isSingleLineNode(node))
+			) {
+				return;
+			}
+
+			const result = merge({node, consequent, alternate}, {
+				checkThrowStatement: true,
+				returnFalseIfNotMergeable: true,
+			});
+
+			if (!result) {
+				return;
+			}
+
+			const problem = {node, messageId};
+
+			// Don't fix if there are comments
+			if (sourceCode.getCommentsInside(node).length > 0) {
+				return problem;
+			}
+
+			const scope = sourceCode.getScope(node);
+			problem.fix = function * (fixer) {
+				const testText = getText(node.test);
+				const consequentText = typeof result.consequent === 'string'
+					? result.consequent
+					: getText(result.consequent);
+				const alternateText = typeof result.alternate === 'string'
+					? result.alternate
+					: getText(result.alternate);
+
+				let {type, before, after} = result;
+
+				let generateNewVariables = false;
+				if (type === 'ThrowStatement') {
+					const scopes = getScopes(scope);
+					const errorName = avoidCapture('error', scopes, isSafeName);
+
+					for (const scope of scopes) {
+						if (!scopeToNamesGeneratedByFixer.has(scope)) {
+							scopeToNamesGeneratedByFixer.set(scope, new Set());
+						}
+
+						const generatedNames = scopeToNamesGeneratedByFixer.get(scope);
+						generatedNames.add(errorName);
+					}
+
+					const indentString = getIndentString(node, sourceCode);
+
+					after = after
+						.replace('{{INDENT_STRING}}', indentString)
+						.replace('{{ERROR_NAME}}', errorName);
+					before = before
+						.replace('{{INDENT_STRING}}', indentString)
+						.replace('{{ERROR_NAME}}', errorName);
+					generateNewVariables = true;
+				}
+
+				let fixed = `${before}${testText} ? ${consequentText} : ${alternateText}${after}`;
+				const tokenBefore = sourceCode.getTokenBefore(node);
+				const shouldAddSemicolonBefore = needsSemicolon(tokenBefore, sourceCode, fixed);
+				if (shouldAddSemicolonBefore) {
+					fixed = `;${fixed}`;
+				}
+
+				yield fixer.replaceText(node, fixed);
+
+				if (generateNewVariables) {
+					yield * extendFixRange(fixer, sourceCode.ast.range);
+				}
+			};
+
+			return problem;
+		},
+	};
+};
+
+const schema = [
+	{
+		enum: ['always', 'only-single-line'],
+		default: 'always',
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer ternary expressions over simple `if-else` statements.',
+		},
+		fixable: 'code',
+		schema,
+		messages: {
+			[messageId]: 'This `if` statement can be replaced by a ternary expression.',
+		},
+	},
+};