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

package/rules/utils/is-same-reference.js

@@ -0,0 +1,173 @@
+'use strict';
+const {getStaticValue} = require('@eslint-community/eslint-utils');
+
+// Copied from https://github.com/eslint/eslint/blob/94ba68d76a6940f68ff82eea7332c6505f93df76/lib/rules/utils/ast-utils.js#L392
+
+/**
+Gets the property name of a given node.
+The node can be a MemberExpression, a Property, or a MethodDefinition.
+
+If the name is dynamic, this returns `null`.
+
+For examples:
+
+	a.b		   // => "b"
+	a["b"]		// => "b"
+	a['b']		// => "b"
+	a[`b`]		// => "b"
+	a[100]		// => "100"
+	a[b]		  // => null
+	a["a" + "b"]  // => null
+	a[tag`b`]	 // => null
+	a[`${b}`]	 // => null
+
+	let a = {b: 1}			// => "b"
+	let a = {["b"]: 1}		// => "b"
+	let a = {['b']: 1}		// => "b"
+	let a = {[`b`]: 1}		// => "b"
+	let a = {[100]: 1}		// => "100"
+	let a = {[b]: 1}		  // => null
+	let a = {["a" + "b"]: 1}  // => null
+	let a = {[tag`b`]: 1}	 // => null
+	let a = {[`${b}`]: 1}	 // => null
+@param {ASTNode} node The node to get.
+@returns {string|undefined} The property name if static. Otherwise, undefined.
+*/
+function getStaticPropertyName(node) {
+	let property;
+
+	switch (node?.type) {
+		case 'MemberExpression': {
+			property = node.property;
+			break;
+		}
+
+		/* c8 ignore next 2 */
+		case 'ChainExpression': {
+			return getStaticPropertyName(node.expression);
+		}
+
+		// Only reachable when use this to get class/object member key
+		/* c8 ignore next */
+		case 'Property':
+		case 'MethodDefinition': {
+			/* c8 ignore next 2 */
+			property = node.key;
+			break;
+		}
+
+			// No default
+	}
+
+	if (property) {
+		if (property.type === 'Identifier' && !node.computed) {
+			return property.name;
+		}
+
+		const staticResult = getStaticValue(property);
+		if (!staticResult) {
+			return;
+		}
+
+		return String(staticResult.value);
+	}
+}
+
+/**
+Check if two literal nodes are the same value.
+@param {ASTNode} left The Literal node to compare.
+@param {ASTNode} right The other Literal node to compare.
+@returns {boolean} `true` if the two literal nodes are the same value.
+*/
+function equalLiteralValue(left, right) {
+	// RegExp literal.
+	if (left.regex || right.regex) {
+		return Boolean(
+			left.regex
+			&& right.regex
+			&& left.regex.pattern === right.regex.pattern
+			&& left.regex.flags === right.regex.flags,
+		);
+	}
+
+	// BigInt literal.
+	if (left.bigint || right.bigint) {
+		return left.bigint === right.bigint;
+	}
+
+	return left.value === right.value;
+}
+
+/**
+Check if two expressions reference the same value. For example:
+	a = a
+	a.b = a.b
+	a[0] = a[0]
+	a['b'] = a['b']
+@param {ASTNode} left The left side of the comparison.
+@param {ASTNode} right The right side of the comparison.
+@returns {boolean} `true` if both sides match and reference the same value.
+*/
+function isSameReference(left, right) {
+	if (left.type !== right.type) {
+		// Handle `a.b` and `a?.b` are samely.
+		if (left.type === 'ChainExpression') {
+			return isSameReference(left.expression, right);
+		}
+
+		if (right.type === 'ChainExpression') {
+			return isSameReference(left, right.expression);
+		}
+
+		return false;
+	}
+
+	switch (left.type) {
+		case 'Super':
+		case 'ThisExpression': {
+			return true;
+		}
+
+		case 'Identifier':
+		case 'PrivateIdentifier': {
+			return left.name === right.name;
+		}
+
+		case 'Literal': {
+			return equalLiteralValue(left, right);
+		}
+
+		case 'ChainExpression': {
+			return isSameReference(left.expression, right.expression);
+		}
+
+		case 'MemberExpression': {
+			const nameA = getStaticPropertyName(left);
+
+			// `x.y = x["y"]`
+			if (nameA !== undefined) {
+				return (
+					isSameReference(left.object, right.object)
+					&& nameA === getStaticPropertyName(right)
+				);
+			}
+
+			/*
+			`x[0] = x[0]`
+			`x[y] = x[y]`
+			`x.y = x.y`
+			*/
+			return (
+				left.computed === right.computed
+				&& isSameReference(left.object, right.object)
+				&& isSameReference(left.property, right.property)
+			);
+		}
+
+		default: {
+			return false;
+		}
+	}
+}
+
+module.exports = isSameReference;

package/rules/utils/is-shadowed.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * Finds the eslint-scope reference in the given scope.
+ * @param {Object} scope The scope to search.
+ * @param {ASTNode} node The identifier node.
+ * @returns {Reference|undefined} Returns the found reference or null if none were found.
+ */
+function findReference(scope, node) {
+	const references = scope.references
+		.filter(reference => reference.identifier === node);
+
+	if (references.length === 1) {
+		return references[0];
+	}
+}
+
+/**
+ * Checks if the given identifier node is shadowed in the given scope.
+ * @param {Object} scope The current scope.
+ * @param {string} node The identifier node to check
+ * @returns {boolean} Whether or not the name is shadowed.
+ */
+function isShadowed(scope, node) {
+	const reference = findReference(scope, node);
+
+	return (
+		Boolean(reference?.resolved)
+		&& reference.resolved.defs.length > 0
+	);
+}
+
+module.exports = isShadowed;

package/rules/utils/is-shorthand-export-local.js

@@ -0,0 +1,9 @@
+'use strict';
+const hasSameRange = require('./has-same-range.js');
+
+const isShorthandExportLocal = node => {
+	const {type, local, exported} = node.parent;
+	return type === 'ExportSpecifier' && hasSameRange(local, exported) && local === node;
+};
+
+module.exports = isShorthandExportLocal;

package/rules/utils/is-shorthand-import-local.js

@@ -0,0 +1,9 @@
+'use strict';
+const hasSameRange = require('./has-same-range.js');
+
+const isShorthandImportLocal = node => {
+	const {type, local, imported} = node.parent;
+	return type === 'ImportSpecifier' && hasSameRange(local, imported) && local === node;
+};
+
+module.exports = isShorthandImportLocal;

package/rules/utils/is-shorthand-property-assignment-pattern-left.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const isShorthandPropertyValue = require('./is-shorthand-property-value.js');
+
+const isShorthandPropertyAssignmentPatternLeft = identifier =>
+	identifier.parent.type === 'AssignmentPattern'
+	&& identifier.parent.left === identifier
+	&& isShorthandPropertyValue(identifier.parent);
+
+module.exports = isShorthandPropertyAssignmentPatternLeft;

package/rules/utils/is-shorthand-property-value.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const isShorthandPropertyValue = identifier =>
+	identifier.parent.type === 'Property'
+	&& identifier.parent.shorthand
+	&& identifier === identifier.parent.value;
+
+module.exports = isShorthandPropertyValue;

package/rules/utils/is-value-not-usable.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const {isExpressionStatement} = require('../ast/index.js');
+
+module.exports = node => isExpressionStatement(node.parent);