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

package/rules/no-useless-promise-resolve-reject.js

@@ -0,0 +1,212 @@
+'use strict';
+const {getParenthesizedRange} = require('./utils/index.js');
+const {isFunction, isMethodCall} = require('./ast/index.js');
+
+const MESSAGE_ID_RESOLVE = 'resolve';
+const MESSAGE_ID_REJECT = 'reject';
+const messages = {
+	[MESSAGE_ID_RESOLVE]: 'Prefer `{{type}} value` over `{{type}} Promise.resolve(value)`.',
+	[MESSAGE_ID_REJECT]: 'Prefer `throw error` over `{{type}} Promise.reject(error)`.',
+};
+
+function getFunctionNode(node) {
+	let isInTryStatement = false;
+	let functionNode;
+	for (; node; node = node.parent) {
+		if (isFunction(node)) {
+			functionNode = node;
+			break;
+		}
+
+		if (node.type === 'TryStatement') {
+			isInTryStatement = true;
+		}
+	}
+
+	return {
+		functionNode,
+		isInTryStatement,
+	};
+}
+
+function isPromiseCallback(node) {
+	if (
+		node.parent.type === 'CallExpression'
+		&& node.parent.callee.type === 'MemberExpression'
+		&& !node.parent.callee.computed
+		&& node.parent.callee.property.type === 'Identifier'
+	) {
+		const {callee: {property}, arguments: arguments_} = node.parent;
+
+		if (
+			arguments_.length === 1
+			&& (
+				property.name === 'then'
+				|| property.name === 'catch'
+				|| property.name === 'finally'
+			)
+			&& arguments_[0] === node
+		) {
+			return true;
+		}
+
+		if (
+			arguments_.length === 2
+			&& property.name === 'then'
+			&& (
+				arguments_[0] === node
+				|| (arguments_[0].type !== 'SpreadElement' && arguments_[1] === node)
+			)
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+function createProblem(callExpression, fix) {
+	const {callee, parent} = callExpression;
+	const method = callee.property.name;
+	const type = parent.type === 'YieldExpression' ? 'yield' : 'return';
+
+	return {
+		node: callee,
+		messageId: method,
+		data: {type},
+		fix,
+	};
+}
+
+function fix(callExpression, isInTryStatement, sourceCode) {
+	if (callExpression.arguments.length > 1) {
+		return;
+	}
+
+	const {callee, parent, arguments: [errorOrValue]} = callExpression;
+	if (errorOrValue?.type === 'SpreadElement') {
+		return;
+	}
+
+	const isReject = callee.property.name === 'reject';
+	const isYieldExpression = parent.type === 'YieldExpression';
+	if (
+		isReject
+		&& (
+			isInTryStatement
+			|| (isYieldExpression && parent.parent.type !== 'ExpressionStatement')
+		)
+	) {
+		return;
+	}
+
+	return function (fixer) {
+		const isArrowFunctionBody = parent.type === 'ArrowFunctionExpression';
+
+		let text = errorOrValue ? sourceCode.getText(errorOrValue) : '';
+
+		if (errorOrValue?.type === 'SequenceExpression') {
+			text = `(${text})`;
+		}
+
+		if (isReject) {
+			// `return Promise.reject()` -> `throw undefined`
+			text = text || 'undefined';
+			text = `throw ${text}`;
+
+			if (isYieldExpression) {
+				return fixer.replaceTextRange(
+					getParenthesizedRange(parent, sourceCode),
+					text,
+				);
+			}
+
+			text += ';';
+
+			// `=> Promise.reject(error)` -> `=> { throw error; }`
+			if (isArrowFunctionBody) {
+				text = `{ ${text} }`;
+				return fixer.replaceTextRange(
+					getParenthesizedRange(callExpression, sourceCode),
+					text,
+				);
+			}
+		} else {
+			// eslint-disable-next-line no-lonely-if
+			if (isYieldExpression) {
+				text = `yield${text ? ' ' : ''}${text}`;
+			} else if (parent.type === 'ReturnStatement') {
+				text = `return${text ? ' ' : ''}${text};`;
+			} else {
+				if (errorOrValue?.type === 'ObjectExpression') {
+					text = `(${text})`;
+				}
+
+				// `=> Promise.resolve()` -> `=> {}`
+				text = text || '{}';
+			}
+		}
+
+		return fixer.replaceText(
+			isArrowFunctionBody ? callExpression : parent,
+			text,
+		);
+	};
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		CallExpression(callExpression) {
+			if (!(
+				isMethodCall(callExpression, {
+					object: 'Promise',
+					methods: ['resolve', 'reject'],
+					optionalCall: false,
+					optionalMember: false,
+				})
+				&& (
+					(
+						callExpression.parent.type === 'ArrowFunctionExpression'
+						&& callExpression.parent.body === callExpression
+					)
+					|| (
+						callExpression.parent.type === 'ReturnStatement'
+						&& callExpression.parent.argument === callExpression
+					)
+					|| (
+						callExpression.parent.type === 'YieldExpression'
+						&& !callExpression.parent.delegate && callExpression.parent.argument === callExpression
+					)
+				)
+			)) {
+				return;
+			}
+
+			const {functionNode, isInTryStatement} = getFunctionNode(callExpression);
+			if (!functionNode || !(functionNode.async || isPromiseCallback(functionNode))) {
+				return;
+			}
+
+			return createProblem(
+				callExpression,
+				fix(callExpression, isInTryStatement, sourceCode),
+			);
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow returning/yielding `Promise.resolve/reject()` in async functions or promise callbacks',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-useless-spread.js

@@ -0,0 +1,381 @@
+'use strict';
+const {isCommaToken} = require('@eslint-community/eslint-utils');
+const typedArray = require('./shared/typed-array.js');
+const {
+	removeParentheses,
+	fixSpaceAroundKeyword,
+	addParenthesizesToReturnOrThrowExpression,
+} = require('./fix/index.js');
+const {
+	isParenthesized,
+	isOnSameLine,
+} = require('./utils/index.js');
+const {isNewExpression, isMethodCall, isCallOrNewExpression} = require('./ast/index.js');
+
+const SPREAD_IN_LIST = 'spread-in-list';
+const ITERABLE_TO_ARRAY = 'iterable-to-array';
+const ITERABLE_TO_ARRAY_IN_FOR_OF = 'iterable-to-array-in-for-of';
+const ITERABLE_TO_ARRAY_IN_YIELD_STAR = 'iterable-to-array-in-yield-star';
+const CLONE_ARRAY = 'clone-array';
+const messages = {
+	[SPREAD_IN_LIST]: 'Spread an {{argumentType}} literal in {{parentDescription}} is unnecessary.',
+	[ITERABLE_TO_ARRAY]: '`{{parentDescription}}` accepts iterable as argument, it\'s unnecessary to convert to an array.',
+	[ITERABLE_TO_ARRAY_IN_FOR_OF]: '`for…of` can iterate over iterable, it\'s unnecessary to convert to an array.',
+	[ITERABLE_TO_ARRAY_IN_YIELD_STAR]: '`yield*` can delegate iterable, it\'s unnecessary to convert to an array.',
+	[CLONE_ARRAY]: 'Unnecessarily cloning an array.',
+};
+
+const isSingleArraySpread = node =>
+	node.type === 'ArrayExpression'
+	&& node.elements.length === 1
+	&& node.elements[0]?.type === 'SpreadElement';
+
+const parentDescriptions = {
+	ArrayExpression: 'array literal',
+	ObjectExpression: 'object literal',
+	CallExpression: 'arguments',
+	NewExpression: 'arguments',
+};
+
+function getCommaTokens(arrayExpression, sourceCode) {
+	let startToken = sourceCode.getFirstToken(arrayExpression);
+
+	return arrayExpression.elements.map((element, index, elements) => {
+		if (index === elements.length - 1) {
+			const penultimateToken = sourceCode.getLastToken(arrayExpression, {skip: 1});
+			if (isCommaToken(penultimateToken)) {
+				return penultimateToken;
+			}
+
+			return;
+		}
+
+		const commaToken = sourceCode.getTokenAfter(element || startToken, isCommaToken);
+		startToken = commaToken;
+		return commaToken;
+	});
+}
+
+function * unwrapSingleArraySpread(fixer, arrayExpression, sourceCode) {
+	const [
+		openingBracketToken,
+		spreadToken,
+		thirdToken,
+	] = sourceCode.getFirstTokens(arrayExpression, 3);
+
+	// `[...value]`
+	//  ^
+	yield fixer.remove(openingBracketToken);
+
+	// `[...value]`
+	//   ^^^
+	yield fixer.remove(spreadToken);
+
+	const [
+		commaToken,
+		closingBracketToken,
+	] = sourceCode.getLastTokens(arrayExpression, 2);
+
+	// `[...value]`
+	//           ^
+	yield fixer.remove(closingBracketToken);
+
+	// `[...value,]`
+	//           ^
+	if (isCommaToken(commaToken)) {
+		yield fixer.remove(commaToken);
+	}
+
+	/*
+	```js
+	function foo() {
+		return [
+			...value,
+		];
+	}
+	```
+	*/
+	const {parent} = arrayExpression;
+	if (
+		(parent.type === 'ReturnStatement' || parent.type === 'ThrowStatement')
+		&& parent.argument === arrayExpression
+		&& !isOnSameLine(openingBracketToken, thirdToken)
+		&& !isParenthesized(arrayExpression, sourceCode)
+	) {
+		yield * addParenthesizesToReturnOrThrowExpression(fixer, parent, sourceCode);
+		return;
+	}
+
+	yield * fixSpaceAroundKeyword(fixer, arrayExpression, sourceCode);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	// Useless spread in list
+	context.on(['ArrayExpression', 'ObjectExpression'], node => {
+		if (!(
+			node.parent.type === 'SpreadElement'
+			&& node.parent.argument === node
+			&& (
+				(
+					node.type === 'ObjectExpression'
+					&& node.parent.parent.type === 'ObjectExpression'
+					&& node.parent.parent.properties.includes(node.parent)
+				)
+				|| (
+					node.type === 'ArrayExpression'
+					&& (
+						(
+							node.parent.parent.type === 'ArrayExpression'
+							&& node.parent.parent.elements.includes(node.parent)
+						)
+						|| (
+							isCallOrNewExpression(node.parent.parent)
+							&& node.parent.parent.arguments.includes(node.parent)
+						)
+					)
+				)
+			)
+		)) {
+			return;
+		}
+
+		const spreadObject = node;
+		const spreadElement = spreadObject.parent;
+		const spreadToken = sourceCode.getFirstToken(spreadElement);
+		const parentType = spreadElement.parent.type;
+
+		return {
+			node: spreadToken,
+			messageId: SPREAD_IN_LIST,
+			data: {
+				argumentType: spreadObject.type === 'ArrayExpression' ? 'array' : 'object',
+				parentDescription: parentDescriptions[parentType],
+			},
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			* fix(fixer) {
+				// `[...[foo]]`
+				//   ^^^
+				yield fixer.remove(spreadToken);
+
+				// `[...(( [foo] ))]`
+				//      ^^       ^^
+				yield * removeParentheses(spreadObject, fixer, sourceCode);
+
+				// `[...[foo]]`
+				//      ^
+				const firstToken = sourceCode.getFirstToken(spreadObject);
+				yield fixer.remove(firstToken);
+
+				const [
+					penultimateToken,
+					lastToken,
+				] = sourceCode.getLastTokens(spreadObject, 2);
+
+				// `[...[foo]]`
+				//          ^
+				yield fixer.remove(lastToken);
+
+				// `[...[foo,]]`
+				//          ^
+				if (isCommaToken(penultimateToken)) {
+					yield fixer.remove(penultimateToken);
+				}
+
+				if (parentType !== 'CallExpression' && parentType !== 'NewExpression') {
+					return;
+				}
+
+				const commaTokens = getCommaTokens(spreadObject, sourceCode);
+				for (const [index, commaToken] of commaTokens.entries()) {
+					if (spreadObject.elements[index]) {
+						continue;
+					}
+
+					// `call(...[foo, , bar])`
+					//               ^ Replace holes with `undefined`
+					yield fixer.insertTextBefore(commaToken, 'undefined');
+				}
+			},
+		};
+	});
+
+	// Useless iterable to array
+	context.on('ArrayExpression', arrayExpression => {
+		if (!isSingleArraySpread(arrayExpression)) {
+			return;
+		}
+
+		const {parent} = arrayExpression;
+		if (!(
+			(parent.type === 'ForOfStatement' && parent.right === arrayExpression)
+			|| (parent.type === 'YieldExpression' && parent.delegate && parent.argument === arrayExpression)
+			|| (
+				(
+					isNewExpression(parent, {names: ['Map', 'WeakMap', 'Set', 'WeakSet'], argumentsLength: 1})
+					|| isNewExpression(parent, {names: typedArray, minimumArguments: 1})
+					|| isMethodCall(parent, {
+						object: 'Promise',
+						methods: ['all', 'allSettled', 'any', 'race'],
+						argumentsLength: 1,
+						optionalCall: false,
+						optionalMember: false,
+					})
+					|| isMethodCall(parent, {
+						objects: ['Array', ...typedArray],
+						method: 'from',
+						argumentsLength: 1,
+						optionalCall: false,
+						optionalMember: false,
+					})
+					|| isMethodCall(parent, {
+						object: 'Object',
+						method: 'fromEntries',
+						argumentsLength: 1,
+						optionalCall: false,
+						optionalMember: false,
+					})
+				)
+				&& parent.arguments[0] === arrayExpression
+			)
+		)) {
+			return;
+		}
+
+		let parentDescription = '';
+		let messageId = ITERABLE_TO_ARRAY;
+		switch (parent.type) {
+			case 'ForOfStatement': {
+				messageId = ITERABLE_TO_ARRAY_IN_FOR_OF;
+				break;
+			}
+
+			case 'YieldExpression': {
+				messageId = ITERABLE_TO_ARRAY_IN_YIELD_STAR;
+				break;
+			}
+
+			case 'NewExpression': {
+				parentDescription = `new ${parent.callee.name}(…)`;
+				break;
+			}
+
+			case 'CallExpression': {
+				parentDescription = `${parent.callee.object.name}.${parent.callee.property.name}(…)`;
+				break;
+			}
+			// No default
+		}
+
+		return {
+			node: arrayExpression,
+			messageId,
+			data: {parentDescription},
+			fix: fixer => unwrapSingleArraySpread(fixer, arrayExpression, sourceCode),
+		};
+	});
+
+	// Useless array clone
+	context.on('ArrayExpression', arrayExpression => {
+		if (!isSingleArraySpread(arrayExpression)) {
+			return;
+		}
+
+		const node = arrayExpression.elements[0].argument;
+		if (!(
+			// Array methods returns a new array
+			isMethodCall(node, {
+				methods: [
+					'concat',
+					'copyWithin',
+					'filter',
+					'flat',
+					'flatMap',
+					'map',
+					'slice',
+					'splice',
+					'toReversed',
+					'toSorted',
+					'toSpliced',
+					'with',
+				],
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `String#split()`
+			|| isMethodCall(node, {
+				method: 'split',
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `Object.keys()` and `Object.values()`
+			|| isMethodCall(node, {
+				object: 'Object',
+				methods: ['keys', 'values'],
+				argumentsLength: 1,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `await Promise.all()` and `await Promise.allSettled`
+			|| (
+				node.type === 'AwaitExpression'
+				&& isMethodCall(node.argument, {
+					object: 'Promise',
+					methods: ['all', 'allSettled'],
+					argumentsLength: 1,
+					optionalCall: false,
+					optionalMember: false,
+				})
+			)
+			// `Array.from()`, `Array.of()`
+			|| isMethodCall(node, {
+				object: 'Array',
+				methods: ['from', 'of'],
+				optionalCall: false,
+				optionalMember: false,
+			})
+			// `new Array()`
+			|| isNewExpression(node, {name: 'Array'})
+		)) {
+			return;
+		}
+
+		const problem = {
+			node: arrayExpression,
+			messageId: CLONE_ARRAY,
+		};
+
+		if (
+			// `[...new Array(1)]` -> `new Array(1)` is not safe to fix since there are holes
+			isNewExpression(node, {name: 'Array'})
+			// `[...foo.slice(1)]` -> `foo.slice(1)` is not safe to fix since `foo` can be a string
+			|| (
+				node.type === 'CallExpression'
+				&& node.callee.type === 'MemberExpression'
+				&& node.callee.property.type === 'Identifier'
+				&& node.callee.property.name === 'slice'
+			)
+		) {
+			return problem;
+		}
+
+		return Object.assign(problem, {
+			fix: fixer => unwrapSingleArraySpread(fixer, arrayExpression, sourceCode),
+		});
+	});
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow unnecessary spread.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-useless-switch-case.js

@@ -0,0 +1,71 @@
+'use strict';
+const {isEmptyNode} = require('./ast/index.js');
+const getSwitchCaseHeadLocation = require('./utils/get-switch-case-head-location.js');
+
+const MESSAGE_ID_ERROR = 'no-useless-switch-case/error';
+const MESSAGE_ID_SUGGESTION = 'no-useless-switch-case/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Useless case in switch statement.',
+	[MESSAGE_ID_SUGGESTION]: 'Remove this case.',
+};
+
+const isEmptySwitchCase = node => node.consequent.every(node => isEmptyNode(node));
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	* SwitchStatement(switchStatement) {
+		const {cases} = switchStatement;
+
+		// TypeScript allows multiple `default` cases
+		const defaultCases = cases.filter(switchCase => switchCase.test === null);
+		if (defaultCases.length !== 1) {
+			return;
+		}
+
+		const [defaultCase] = defaultCases;
+
+		// We only check cases where the last case is the `default` case
+		if (defaultCase !== cases.at(-1)) {
+			return;
+		}
+
+		const uselessCases = [];
+
+		for (let index = cases.length - 2; index >= 0; index--) {
+			const node = cases[index];
+			if (isEmptySwitchCase(node)) {
+				uselessCases.unshift(node);
+			} else {
+				break;
+			}
+		}
+
+		for (const node of uselessCases) {
+			yield {
+				node,
+				loc: getSwitchCaseHeadLocation(node, context.sourceCode),
+				messageId: MESSAGE_ID_ERROR,
+				suggest: [
+					{
+						messageId: MESSAGE_ID_SUGGESTION,
+						/** @param {import('eslint').Rule.RuleFixer} fixer */
+						fix: fixer => fixer.remove(node),
+					},
+				],
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless case in switch statements.',
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};