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

package/rules/no-unreadable-array-destructuring.js

@@ -0,0 +1,83 @@
+'use strict';
+const {isParenthesized} = require('@eslint-community/eslint-utils');
+const shouldAddParenthesesToMemberExpressionObject = require('./utils/should-add-parentheses-to-member-expression-object.js');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+
+const MESSAGE_ID = 'no-unreadable-array-destructuring';
+const messages = {
+	[MESSAGE_ID]: 'Array destructuring may not contain consecutive ignored values.',
+};
+
+const isCommaFollowedWithComma = (element, index, array) =>
+	element === null && array[index + 1] === null;
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		ArrayPattern(node) {
+			const {elements, parent} = node;
+
+			if (
+				elements.length < 3
+				|| !elements.some((element, index, elements) => isCommaFollowedWithComma(element, index, elements))) {
+				return;
+			}
+
+			const problem = {
+				node,
+				messageId: MESSAGE_ID,
+			};
+
+			const nonNullElements = elements.filter(node => node !== null);
+			if (
+				parent.type === 'VariableDeclarator'
+				&& parent.id === node
+				&& parent.init !== null
+				&& nonNullElements.length === 1
+			) {
+				const [element] = nonNullElements;
+
+				if (element.type !== 'AssignmentPattern') {
+					problem.fix = function * (fixer) {
+						const index = elements.indexOf(element);
+						const isSlice = element.type === 'RestElement';
+						const variable = isSlice ? element.argument : element;
+
+						yield fixer.replaceText(node, sourceCode.getText(variable));
+
+						const code = isSlice ? `.slice(${index})` : `[${index}]`;
+						const array = parent.init;
+						if (
+							!isParenthesized(array, sourceCode)
+							&& shouldAddParenthesesToMemberExpressionObject(array, sourceCode)
+						) {
+							yield fixer.insertTextBefore(array, '(');
+							yield fixer.insertTextAfter(parent, `)${code}`);
+						} else {
+							yield fixer.insertTextAfter(parent, code);
+						}
+
+						yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+					};
+				}
+			}
+
+			return problem;
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow unreadable array destructuring.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-unreadable-iife.js

@@ -0,0 +1,45 @@
+'use strict';
+const {
+	isParenthesized,
+	getParenthesizedRange,
+	toLocation,
+} = require('./utils/index.js');
+
+const MESSAGE_ID_ERROR = 'no-unreadable-iife';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'IIFE with parenthesized arrow function body is considered unreadable.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(callExpression) {
+		const {sourceCode} = context;
+
+		if (
+			callExpression.callee.type !== 'ArrowFunctionExpression'
+			|| callExpression.callee.body.type === 'BlockStatement'
+			|| !isParenthesized(callExpression.callee.body, sourceCode)
+		) {
+			return;
+		}
+
+		return {
+			node: callExpression,
+			loc: toLocation(getParenthesizedRange(callExpression.callee.body, sourceCode), sourceCode),
+			messageId: MESSAGE_ID_ERROR,
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow unreadable IIFEs.',
+		},
+		hasSuggestions: false,
+		messages,
+	},
+};

package/rules/no-unused-properties.js

@@ -0,0 +1,238 @@
+'use strict';
+const getScopes = require('./utils/get-scopes.js');
+
+const MESSAGE_ID = 'no-unused-properties';
+const messages = {
+	[MESSAGE_ID]: 'Property `{{name}}` is defined but never used.',
+};
+
+const getDeclaratorOrPropertyValue = declaratorOrProperty =>
+	declaratorOrProperty.init
+	|| declaratorOrProperty.value;
+
+const isMemberExpressionCall = memberExpression =>
+	memberExpression.parent.type === 'CallExpression'
+	&& memberExpression.parent.callee === memberExpression;
+
+const isMemberExpressionAssignment = memberExpression =>
+	memberExpression.parent.type === 'AssignmentExpression';
+
+const isMemberExpressionComputedBeyondPrediction = memberExpression =>
+	memberExpression.computed
+	&& memberExpression.property.type !== 'Literal';
+
+const specialProtoPropertyKey = {
+	type: 'Identifier',
+	name: '__proto__',
+};
+
+const propertyKeysEqual = (keyA, keyB) => {
+	if (keyA.type === 'Identifier') {
+		if (keyB.type === 'Identifier') {
+			return keyA.name === keyB.name;
+		}
+
+		if (keyB.type === 'Literal') {
+			return keyA.name === keyB.value;
+		}
+	}
+
+	if (keyA.type === 'Literal') {
+		if (keyB.type === 'Identifier') {
+			return keyA.value === keyB.name;
+		}
+
+		if (keyB.type === 'Literal') {
+			return keyA.value === keyB.value;
+		}
+	}
+
+	return false;
+};
+
+const objectPatternMatchesObjectExprPropertyKey = (pattern, key) =>
+	pattern.properties.some(property => {
+		if (property.type === 'RestElement') {
+			return true;
+		}
+
+		return propertyKeysEqual(property.key, key);
+	});
+
+const isLeafDeclaratorOrProperty = declaratorOrProperty => {
+	const value = getDeclaratorOrPropertyValue(declaratorOrProperty);
+
+	if (!value) {
+		return true;
+	}
+
+	if (value.type !== 'ObjectExpression') {
+		return true;
+	}
+
+	return false;
+};
+
+const isUnusedVariable = variable => {
+	const hasReadReference = variable.references.some(reference => reference.isRead());
+	return !hasReadReference;
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const getPropertyDisplayName = property => {
+		if (property.key.type === 'Identifier') {
+			return property.key.name;
+		}
+
+		if (property.key.type === 'Literal') {
+			return property.key.value;
+		}
+
+		return sourceCode.getText(property.key);
+	};
+
+	const checkProperty = (property, references, path) => {
+		if (references.length === 0) {
+			context.report({
+				node: property,
+				messageId: MESSAGE_ID,
+				data: {
+					name: getPropertyDisplayName(property),
+				},
+			});
+			return;
+		}
+
+		checkObject(property, references, path);
+	};
+
+	const checkProperties = (objectExpression, references, path = []) => {
+		for (const property of objectExpression.properties) {
+			const {key} = property;
+
+			if (!key) {
+				continue;
+			}
+
+			if (propertyKeysEqual(key, specialProtoPropertyKey)) {
+				continue;
+			}
+
+			const nextPath = [...path, key];
+
+			const nextReferences = references
+				.map(reference => {
+					const {parent} = reference.identifier;
+
+					if (reference.init) {
+						if (
+							parent.type === 'VariableDeclarator'
+							&& parent.parent.type === 'VariableDeclaration'
+							&& parent.parent.parent.type === 'ExportNamedDeclaration'
+						) {
+							return {identifier: parent};
+						}
+
+						return;
+					}
+
+					if (parent.type === 'MemberExpression') {
+						if (
+							isMemberExpressionAssignment(parent)
+							|| isMemberExpressionCall(parent)
+							|| isMemberExpressionComputedBeyondPrediction(parent)
+							|| propertyKeysEqual(parent.property, key)
+						) {
+							return {identifier: parent};
+						}
+
+						return;
+					}
+
+					if (
+						parent.type === 'VariableDeclarator'
+						&& parent.id.type === 'ObjectPattern'
+					) {
+						if (objectPatternMatchesObjectExprPropertyKey(parent.id, key)) {
+							return {identifier: parent};
+						}
+
+						return;
+					}
+
+					if (
+						parent.type === 'AssignmentExpression'
+						&& parent.left.type === 'ObjectPattern'
+					) {
+						if (objectPatternMatchesObjectExprPropertyKey(parent.left, key)) {
+							return {identifier: parent};
+						}
+
+						return;
+					}
+
+					return reference;
+				})
+				.filter(Boolean);
+
+			checkProperty(property, nextReferences, nextPath);
+		}
+	};
+
+	const checkObject = (declaratorOrProperty, references, path) => {
+		if (isLeafDeclaratorOrProperty(declaratorOrProperty)) {
+			return;
+		}
+
+		const value = getDeclaratorOrPropertyValue(declaratorOrProperty);
+
+		checkProperties(value, references, path);
+	};
+
+	const checkVariable = variable => {
+		if (variable.defs.length !== 1) {
+			return;
+		}
+
+		if (isUnusedVariable(variable)) {
+			return;
+		}
+
+		const [definition] = variable.defs;
+
+		checkObject(definition.node, variable.references);
+	};
+
+	const checkVariables = scope => {
+		for (const variable of scope.variables) {
+			checkVariable(variable);
+		}
+	};
+
+	return {
+		'Program:exit'(program) {
+			const scopes = getScopes(sourceCode.getScope(program));
+			for (const scope of scopes) {
+				if (scope.type === 'global') {
+					continue;
+				}
+
+				checkVariables(scope);
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow unused object properties.',
+		},
+		messages,
+	},
+};

package/rules/no-useless-fallback-in-spread.js

@@ -0,0 +1,68 @@
+'use strict';
+const {
+	isParenthesized,
+	getParenthesizedRange,
+} = require('./utils/parentheses.js');
+const {removeParentheses} = require('./fix/index.js');
+const shouldAddParenthesesToSpreadElementArgument = require('./utils/should-add-parentheses-to-spread-element-argument.js');
+
+const MESSAGE_ID = 'no-useless-fallback-in-spread';
+const messages = {
+	[MESSAGE_ID]: 'The empty object is useless.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	ObjectExpression(node) {
+		if (!(
+			node.properties.length === 0
+			&& node.parent.type === 'LogicalExpression'
+			&& node.parent.right === node
+			&& (node.parent.operator === '||' || node.parent.operator === '??')
+			&& node.parent.parent.type === 'SpreadElement'
+			&& node.parent.parent.argument === node.parent
+			&& node.parent.parent.parent.type === 'ObjectExpression'
+			&& node.parent.parent.parent.properties.includes(node.parent.parent)
+		)) {
+			return;
+		}
+
+		return {
+			node,
+			messageId: MESSAGE_ID,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			* fix(fixer) {
+				const {sourceCode} = context;
+				const logicalExpression = node.parent;
+				const {left} = logicalExpression;
+				const isLeftObjectParenthesized = isParenthesized(left, sourceCode);
+				const [, start] = isLeftObjectParenthesized
+					? getParenthesizedRange(left, sourceCode)
+					: left.range;
+				const [, end] = logicalExpression.range;
+
+				yield fixer.removeRange([start, end]);
+
+				if (
+					isLeftObjectParenthesized
+					|| !shouldAddParenthesesToSpreadElementArgument(left)
+				) {
+					yield * removeParentheses(logicalExpression, fixer, sourceCode);
+				}
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless fallback when spreading in object literals.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-useless-length-check.js

@@ -0,0 +1,152 @@
+'use strict';
+const {isMethodCall, isMemberExpression} = require('./ast/index.js');
+const {
+	getParenthesizedRange,
+	isSameReference,
+	isLogicalExpression,
+} = require('./utils/index.js');
+
+const messages = {
+	'non-zero': 'The non-empty check is useless as `Array#some()` returns `false` for an empty array.',
+	zero: 'The empty check is useless as `Array#every()` returns `true` for an empty array.',
+};
+
+// We assume the user already follows `unicorn/explicit-length-check`. These are allowed in that rule.
+const isLengthCompareZero = node =>
+	node.type === 'BinaryExpression'
+	&& node.right.type === 'Literal'
+	&& node.right.raw === '0'
+	&& isMemberExpression(node.left, {property: 'length', optional: false})
+	&& isLogicalExpression(node.parent);
+
+function flatLogicalExpression(node) {
+	return [node.left, node.right].flatMap(child =>
+		child.type === 'LogicalExpression' && child.operator === node.operator
+			? flatLogicalExpression(child)
+			: [child],
+	);
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const logicalExpressions = [];
+	const zeroLengthChecks = new Set();
+	const nonZeroLengthChecks = new Set();
+	const arraySomeCalls = new Set();
+	const arrayEveryCalls = new Set();
+
+	function isUselessLengthCheckNode({node, operator, siblings}) {
+		return (
+			(
+				operator === '||'
+				&& zeroLengthChecks.has(node)
+				&& siblings.some(condition =>
+					arrayEveryCalls.has(condition)
+					&& isSameReference(node.left.object, condition.callee.object),
+				)
+			)
+			|| (
+				operator === '&&'
+				&& nonZeroLengthChecks.has(node)
+				&& siblings.some(condition =>
+					arraySomeCalls.has(condition)
+					&& isSameReference(node.left.object, condition.callee.object),
+				)
+			)
+		);
+	}
+
+	function getUselessLengthCheckNode(logicalExpression) {
+		const {operator} = logicalExpression;
+		return flatLogicalExpression(logicalExpression)
+			.filter((node, index, conditions) => isUselessLengthCheckNode({
+				node,
+				operator,
+				siblings: [
+					conditions[index - 1],
+					conditions[index + 1],
+				].filter(Boolean),
+			}));
+	}
+
+	return {
+		BinaryExpression(node) {
+			if (isLengthCompareZero(node)) {
+				const {operator} = node;
+				if (operator === '===') {
+					zeroLengthChecks.add(node);
+				} else if (operator === '>' || operator === '!==') {
+					nonZeroLengthChecks.add(node);
+				}
+			}
+		},
+		CallExpression(node) {
+			if (
+				isMethodCall(node, {
+					optionalCall: false,
+					optionalMember: false,
+					computed: false,
+				})
+				&& node.callee.property.type === 'Identifier'
+			) {
+				if (node.callee.property.name === 'some') {
+					arraySomeCalls.add(node);
+				} else if (node.callee.property.name === 'every') {
+					arrayEveryCalls.add(node);
+				}
+			}
+		},
+		LogicalExpression(node) {
+			if (isLogicalExpression(node)) {
+				logicalExpressions.push(node);
+			}
+		},
+		* 'Program:exit'() {
+			const nodes = new Set(
+				logicalExpressions.flatMap(logicalExpression =>
+					getUselessLengthCheckNode(logicalExpression),
+				),
+			);
+
+			for (const node of nodes) {
+				yield {
+					loc: {
+						start: node.left.property.loc.start,
+						end: node.loc.end,
+					},
+					messageId: zeroLengthChecks.has(node) ? 'zero' : 'non-zero',
+					/** @param {import('eslint').Rule.RuleFixer} fixer */
+					fix(fixer) {
+						const {sourceCode} = context;
+						const {left, right} = node.parent;
+						const leftRange = getParenthesizedRange(left, sourceCode);
+						const rightRange = getParenthesizedRange(right, sourceCode);
+						const range = [];
+						if (left === node) {
+							range[0] = leftRange[0];
+							range[1] = rightRange[0];
+						} else {
+							range[0] = leftRange[1];
+							range[1] = rightRange[1];
+						}
+
+						return fixer.removeRange(range);
+					},
+				};
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless array length check.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};