bahlint 28.58.6934-dev-001

package/lib/rules/prefer-destructuring.js

@@ -0,0 +1,332 @@
+/**
+ * @fileoverview Prefer destructuring from arrays and objects
+ * @author Alex LaFroscia
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const PRECEDENCE_OF_ASSIGNMENT_EXPR = astUtils.getPrecedence({
+	type: "AssignmentExpression",
+});
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Require destructuring from arrays and/or objects",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/prefer-destructuring",
+		},
+
+		fixable: "code",
+
+		schema: [
+			{
+				/*
+				 * old support {array: Boolean, object: Boolean}
+				 * new support {VariableDeclarator: {}, AssignmentExpression: {}}
+				 */
+				oneOf: [
+					{
+						type: "object",
+						properties: {
+							VariableDeclarator: {
+								type: "object",
+								properties: {
+									array: {
+										type: "boolean",
+									},
+									object: {
+										type: "boolean",
+									},
+								},
+								additionalProperties: false,
+							},
+							AssignmentExpression: {
+								type: "object",
+								properties: {
+									array: {
+										type: "boolean",
+									},
+									object: {
+										type: "boolean",
+									},
+								},
+								additionalProperties: false,
+							},
+						},
+						additionalProperties: false,
+					},
+					{
+						type: "object",
+						properties: {
+							array: {
+								type: "boolean",
+							},
+							object: {
+								type: "boolean",
+							},
+						},
+						additionalProperties: false,
+					},
+				],
+			},
+			{
+				type: "object",
+				properties: {
+					enforceForRenamedProperties: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			preferDestructuring: "Use {{type}} destructuring.",
+		},
+	},
+	create(context) {
+		const enabledTypes = context.options[0];
+		const enforceForRenamedProperties =
+			context.options[1] &&
+			context.options[1].enforceForRenamedProperties;
+		let normalizedOptions = {
+			VariableDeclarator: { array: true, object: true },
+			AssignmentExpression: { array: true, object: true },
+		};
+
+		if (enabledTypes) {
+			normalizedOptions =
+				typeof enabledTypes.array !== "undefined" ||
+				typeof enabledTypes.object !== "undefined"
+					? {
+							VariableDeclarator: enabledTypes,
+							AssignmentExpression: enabledTypes,
+						}
+					: enabledTypes;
+		}
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Checks if destructuring type should be checked.
+		 * @param {string} nodeType "AssignmentExpression" or "VariableDeclarator"
+		 * @param {string} destructuringType "array" or "object"
+		 * @returns {boolean} `true` if the destructuring type should be checked for the given node
+		 */
+		function shouldCheck(nodeType, destructuringType) {
+			return (
+				normalizedOptions &&
+				normalizedOptions[nodeType] &&
+				normalizedOptions[nodeType][destructuringType]
+			);
+		}
+
+		/**
+		 * Determines if the given node is accessing an array index
+		 *
+		 * This is used to differentiate array index access from object property
+		 * access.
+		 * @param {ASTNode} node the node to evaluate
+		 * @returns {boolean} whether or not the node is an integer
+		 */
+		function isArrayIndexAccess(node) {
+			return Number.isInteger(node.property.value);
+		}
+
+		/**
+		 * Report that the given node should use destructuring
+		 * @param {ASTNode} reportNode the node to report
+		 * @param {string} type the type of destructuring that should have been done
+		 * @param {Function|null} fix the fix function or null to pass to context.report
+		 * @returns {void}
+		 */
+		function report(reportNode, type, fix) {
+			context.report({
+				node: reportNode,
+				messageId: "preferDestructuring",
+				data: { type },
+				fix,
+			});
+		}
+
+		/**
+		 * Determines if a node should be fixed into object destructuring
+		 *
+		 * The fixer only fixes the simplest case of object destructuring,
+		 * like: `let x = a.x`;
+		 *
+		 * Assignment expression is not fixed.
+		 * Array destructuring is not fixed.
+		 * Renamed property is not fixed.
+		 * @param {ASTNode} node the node to evaluate
+		 * @returns {boolean} whether or not the node should be fixed
+		 */
+		function shouldFix(node) {
+			return (
+				node.type === "VariableDeclarator" &&
+				node.id.type === "Identifier" &&
+				node.init.type === "MemberExpression" &&
+				!node.init.computed &&
+				node.init.property.type === "Identifier" &&
+				node.id.name === node.init.property.name
+			);
+		}
+
+		/**
+		 * Fix a node into object destructuring.
+		 * This function only handles the simplest case of object destructuring,
+		 * see {@link shouldFix}.
+		 * @param {SourceCodeFixer} fixer the fixer object
+		 * @param {ASTNode} node the node to be fixed.
+		 * @returns {Object} a fix for the node
+		 */
+		function fixIntoObjectDestructuring(fixer, node) {
+			const rightNode = node.init;
+			const sourceCode = context.sourceCode;
+
+			// Don't fix if that would remove any comments. Only comments inside `rightNode.object` can be preserved.
+			if (
+				sourceCode.getCommentsInside(node).length >
+				sourceCode.getCommentsInside(rightNode.object).length
+			) {
+				return null;
+			}
+
+			let objectText = sourceCode.getText(rightNode.object);
+
+			if (
+				astUtils.getPrecedence(rightNode.object) <
+				PRECEDENCE_OF_ASSIGNMENT_EXPR
+			) {
+				objectText = `(${objectText})`;
+			}
+
+			return fixer.replaceText(
+				node,
+				`{${rightNode.property.name}} = ${objectText}`,
+			);
+		}
+
+		/**
+		 * Check that the `prefer-destructuring` rules are followed based on the
+		 * given left- and right-hand side of the assignment.
+		 *
+		 * Pulled out into a separate method so that VariableDeclarators and
+		 * AssignmentExpressions can share the same verification logic.
+		 * @param {ASTNode} leftNode the left-hand side of the assignment
+		 * @param {ASTNode} rightNode the right-hand side of the assignment
+		 * @param {ASTNode} reportNode the node to report the error on
+		 * @returns {void}
+		 */
+		function performCheck(leftNode, rightNode, reportNode) {
+			if (
+				rightNode.type !== "MemberExpression" ||
+				rightNode.object.type === "Super" ||
+				rightNode.property.type === "PrivateIdentifier"
+			) {
+				return;
+			}
+
+			if (isArrayIndexAccess(rightNode)) {
+				if (shouldCheck(reportNode.type, "array")) {
+					report(reportNode, "array", null);
+				}
+				return;
+			}
+
+			const fix = shouldFix(reportNode)
+				? fixer => fixIntoObjectDestructuring(fixer, reportNode)
+				: null;
+
+			if (
+				shouldCheck(reportNode.type, "object") &&
+				enforceForRenamedProperties
+			) {
+				report(reportNode, "object", fix);
+				return;
+			}
+
+			if (shouldCheck(reportNode.type, "object")) {
+				const property = rightNode.property;
+
+				if (
+					(property.type === "Literal" &&
+						leftNode.name === property.value) ||
+					(property.type === "Identifier" &&
+						leftNode.name === property.name &&
+						!rightNode.computed)
+				) {
+					report(reportNode, "object", fix);
+				}
+			}
+		}
+
+		/**
+		 * Check if a given variable declarator is coming from an property access
+		 * that should be using destructuring instead
+		 * @param {ASTNode} node the variable declarator to check
+		 * @returns {void}
+		 */
+		function checkVariableDeclarator(node) {
+			// Skip if variable is declared without assignment
+			if (!node.init) {
+				return;
+			}
+
+			// Variable declarations using explicit resource management cannot use destructuring (parse error)
+			if (
+				node.parent.kind === "using" ||
+				node.parent.kind === "await using"
+			) {
+				return;
+			}
+
+			// We only care about member expressions past this point
+			if (node.init.type !== "MemberExpression") {
+				return;
+			}
+
+			performCheck(node.id, node.init, node);
+		}
+
+		/**
+		 * Run the `prefer-destructuring` check on an AssignmentExpression
+		 * @param {ASTNode} node the AssignmentExpression node
+		 * @returns {void}
+		 */
+		function checkAssignmentExpression(node) {
+			if (node.operator === "=") {
+				performCheck(node.left, node.right, node);
+			}
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			VariableDeclarator: checkVariableDeclarator,
+			AssignmentExpression: checkAssignmentExpression,
+		};
+	},
+};

package/lib/rules/prefer-exponentiation-operator.js

@@ -0,0 +1,235 @@
+/**
+ * @fileoverview Rule to disallow Math.pow in favor of the ** operator
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const PRECEDENCE_OF_EXPONENTIATION_EXPR = astUtils.getPrecedence({
+	type: "BinaryExpression",
+	operator: "**",
+});
+
+/**
+ * Determines whether the given node needs parens if used as the base in an exponentiation binary expression.
+ * @param {ASTNode} base The node to check.
+ * @returns {boolean} `true` if the node needs to be parenthesised.
+ */
+function doesBaseNeedParens(base) {
+	return (
+		// '**' is right-associative, parens are needed when Math.pow(a ** b, c) is converted to (a ** b) ** c
+		astUtils.getPrecedence(base) <= PRECEDENCE_OF_EXPONENTIATION_EXPR ||
+		// An unary operator cannot be used immediately before an exponentiation expression
+		base.type === "AwaitExpression" ||
+		base.type === "UnaryExpression"
+	);
+}
+
+/**
+ * Determines whether the given node needs parens if used as the exponent in an exponentiation binary expression.
+ * @param {ASTNode} exponent The node to check.
+ * @returns {boolean} `true` if the node needs to be parenthesised.
+ */
+function doesExponentNeedParens(exponent) {
+	// '**' is right-associative, there is no need for parens when Math.pow(a, b ** c) is converted to a ** b ** c
+	return astUtils.getPrecedence(exponent) < PRECEDENCE_OF_EXPONENTIATION_EXPR;
+}
+
+/**
+ * Determines whether an exponentiation binary expression at the place of the given node would need parens.
+ * @param {ASTNode} node A node that would be replaced by an exponentiation binary expression.
+ * @param {SourceCode} sourceCode A SourceCode object.
+ * @returns {boolean} `true` if the expression needs to be parenthesised.
+ */
+function doesExponentiationExpressionNeedParens(node, sourceCode) {
+	const parent =
+		node.parent.type === "ChainExpression"
+			? node.parent.parent
+			: node.parent;
+
+	const parentPrecedence = astUtils.getPrecedence(parent);
+	const needsParens =
+		parent.type === "ClassDeclaration" ||
+		(parent.type.endsWith("Expression") &&
+			(parentPrecedence === -1 ||
+				parentPrecedence >= PRECEDENCE_OF_EXPONENTIATION_EXPR) &&
+			!(
+				parent.type === "BinaryExpression" &&
+				parent.operator === "**" &&
+				parent.right === node
+			) &&
+			!(
+				(parent.type === "CallExpression" ||
+					parent.type === "NewExpression") &&
+				parent.arguments.includes(node)
+			) &&
+			!(
+				parent.type === "MemberExpression" &&
+				parent.computed &&
+				parent.property === node
+			) &&
+			!(parent.type === "ArrayExpression"));
+
+	return needsParens && !astUtils.isParenthesised(sourceCode, node);
+}
+
+/**
+ * Optionally parenthesizes given text.
+ * @param {string} text The text to parenthesize.
+ * @param {boolean} shouldParenthesize If `true`, the text will be parenthesised.
+ * @returns {string} parenthesised or unchanged text.
+ */
+function parenthesizeIfShould(text, shouldParenthesize) {
+	return shouldParenthesize ? `(${text})` : text;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow the use of `Math.pow` in favor of the `**` operator",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/prefer-exponentiation-operator",
+		},
+
+		schema: [],
+		fixable: "code",
+
+		messages: {
+			useExponentiation: "Use the '**' operator instead of 'Math.pow'.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Reports the given node.
+		 * @param {ASTNode} node 'Math.pow()' node to report.
+		 * @returns {void}
+		 */
+		function report(node) {
+			context.report({
+				node,
+				messageId: "useExponentiation",
+				fix(fixer) {
+					if (
+						node.arguments.length !== 2 ||
+						node.arguments.some(
+							arg => arg.type === "SpreadElement",
+						) ||
+						sourceCode.getCommentsInside(node).length > 0
+					) {
+						return null;
+					}
+
+					const base = node.arguments[0],
+						exponent = node.arguments[1],
+						baseText = sourceCode.getText(base),
+						exponentText = sourceCode.getText(exponent),
+						shouldParenthesizeBase = doesBaseNeedParens(base),
+						shouldParenthesizeExponent =
+							doesExponentNeedParens(exponent),
+						shouldParenthesizeAll =
+							doesExponentiationExpressionNeedParens(
+								node,
+								sourceCode,
+							);
+
+					let prefix = "",
+						suffix = "";
+
+					if (!shouldParenthesizeAll) {
+						if (!shouldParenthesizeBase) {
+							const firstReplacementToken =
+									sourceCode.getFirstToken(base),
+								tokenBefore = sourceCode.getTokenBefore(node);
+
+							if (
+								tokenBefore &&
+								tokenBefore.range[1] === node.range[0] &&
+								!astUtils.canTokensBeAdjacent(
+									tokenBefore,
+									firstReplacementToken,
+								)
+							) {
+								prefix = " "; // a+Math.pow(++b, c) -> a+ ++b**c
+							}
+						}
+						if (!shouldParenthesizeExponent) {
+							const lastReplacementToken =
+									sourceCode.getLastToken(exponent),
+								tokenAfter = sourceCode.getTokenAfter(node);
+
+							if (
+								tokenAfter &&
+								node.range[1] === tokenAfter.range[0] &&
+								!astUtils.canTokensBeAdjacent(
+									lastReplacementToken,
+									tokenAfter,
+								)
+							) {
+								suffix = " "; // Math.pow(a, b)in c -> a**b in c
+							}
+						}
+					}
+
+					const baseReplacement = parenthesizeIfShould(
+							baseText,
+							shouldParenthesizeBase,
+						),
+						exponentReplacement = parenthesizeIfShould(
+							exponentText,
+							shouldParenthesizeExponent,
+						),
+						replacement = parenthesizeIfShould(
+							`${baseReplacement}**${exponentReplacement}`,
+							shouldParenthesizeAll,
+						);
+
+					return fixer.replaceText(
+						node,
+						`${prefix}${replacement}${suffix}`,
+					);
+				},
+			});
+		}
+
+		return {
+			Program(node) {
+				const scope = sourceCode.getScope(node);
+				const tracker = new ReferenceTracker(scope);
+				const trackMap = {
+					Math: {
+						pow: { [CALL]: true },
+					},
+				};
+
+				for (const { node: refNode } of tracker.iterateGlobalReferences(
+					trackMap,
+				)) {
+					report(refNode);
+				}
+			},
+		};
+	},
+};