bahlint 28.58.6934

package/lib/rules/no-return-await.js

@@ -0,0 +1,162 @@
+/**
+ * @fileoverview Disallows unnecessary `return await`
+ * @author Jordan Harband
+ * @deprecated in ESLint v8.46.0
+ */
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		hasSuggestions: true,
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow unnecessary `return await`",
+
+			recommended: false,
+
+			url: "https://eslint.org/docs/latest/rules/no-return-await",
+		},
+
+		fixable: null,
+
+		deprecated: {
+			message:
+				"The original assumption of the rule no longer holds true because of engine optimization.",
+			deprecatedSince: "8.46.0",
+			availableUntil: null,
+			replacedBy: [],
+		},
+
+		schema: [],
+
+		messages: {
+			removeAwait: "Remove redundant `await`.",
+			redundantUseOfAwait: "Redundant use of `await` on a return value.",
+		},
+	},
+
+	create(context) {
+		/**
+		 * Reports a found unnecessary `await` expression.
+		 * @param {ASTNode} node The node representing the `await` expression to report
+		 * @returns {void}
+		 */
+		function reportUnnecessaryAwait(node) {
+			context.report({
+				node: context.sourceCode.getFirstToken(node),
+				loc: node.loc,
+				messageId: "redundantUseOfAwait",
+				suggest: [
+					{
+						messageId: "removeAwait",
+						fix(fixer) {
+							const sourceCode = context.sourceCode;
+							const [awaitToken, tokenAfterAwait] =
+								sourceCode.getFirstTokens(node, 2);
+
+							const areAwaitAndAwaitedExpressionOnTheSameLine =
+								awaitToken.loc.start.line ===
+								tokenAfterAwait.loc.start.line;
+
+							if (!areAwaitAndAwaitedExpressionOnTheSameLine) {
+								return null;
+							}
+
+							const [startOfAwait, endOfAwait] = awaitToken.range;
+
+							const characterAfterAwait =
+								sourceCode.text[endOfAwait];
+							const trimLength =
+								characterAfterAwait === " " ? 1 : 0;
+
+							const range = [
+								startOfAwait,
+								endOfAwait + trimLength,
+							];
+
+							return fixer.removeRange(range);
+						},
+					},
+				],
+			});
+		}
+
+		/**
+		 * Determines whether a thrown error from this node will be caught/handled within this function rather than immediately halting
+		 * this function. For example, a statement in a `try` block will always have an error handler. A statement in
+		 * a `catch` block will only have an error handler if there is also a `finally` block.
+		 * @param {ASTNode} node A node representing a location where an could be thrown
+		 * @returns {boolean} `true` if a thrown error will be caught/handled in this function
+		 */
+		function hasErrorHandler(node) {
+			let ancestor = node;
+
+			while (
+				!astUtils.isFunction(ancestor) &&
+				ancestor.type !== "Program"
+			) {
+				if (
+					ancestor.parent.type === "TryStatement" &&
+					(ancestor === ancestor.parent.block ||
+						(ancestor === ancestor.parent.handler &&
+							ancestor.parent.finalizer))
+				) {
+					return true;
+				}
+				ancestor = ancestor.parent;
+			}
+			return false;
+		}
+
+		/**
+		 * Checks if a node is placed in tail call position. Once `return` arguments (or arrow function expressions) can be a complex expression,
+		 * an `await` expression could or could not be unnecessary by the definition of this rule. So we're looking for `await` expressions that are in tail position.
+		 * @param {ASTNode} node A node representing the `await` expression to check
+		 * @returns {boolean} The checking result
+		 */
+		function isInTailCallPosition(node) {
+			if (node.parent.type === "ArrowFunctionExpression") {
+				return true;
+			}
+			if (node.parent.type === "ReturnStatement") {
+				return !hasErrorHandler(node.parent);
+			}
+			if (
+				node.parent.type === "ConditionalExpression" &&
+				(node === node.parent.consequent ||
+					node === node.parent.alternate)
+			) {
+				return isInTailCallPosition(node.parent);
+			}
+			if (
+				node.parent.type === "LogicalExpression" &&
+				node === node.parent.right
+			) {
+				return isInTailCallPosition(node.parent);
+			}
+			if (
+				node.parent.type === "SequenceExpression" &&
+				node === node.parent.expressions.at(-1)
+			) {
+				return isInTailCallPosition(node.parent);
+			}
+			return false;
+		}
+
+		return {
+			AwaitExpression(node) {
+				if (isInTailCallPosition(node) && !hasErrorHandler(node)) {
+					reportUnnecessaryAwait(node);
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-script-url.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Rule to disallow `javascript:` URLs
+ * @author Ilya Volodin
+ */
+/* eslint no-script-url: 0 -- Code is checking to report such URLs */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow `javascript:` URLs",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-script-url",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpectedScriptURL: "Script URL is a form of eval.",
+		},
+	},
+
+	create(context) {
+		/**
+		 * Check whether a node's static value starts with `javascript:` or not.
+		 * And report an error for unexpected script URL.
+		 * @param {ASTNode} node node to check
+		 * @returns {void}
+		 */
+		function check(node) {
+			const value = astUtils.getStaticStringValue(node);
+
+			if (
+				typeof value === "string" &&
+				value.toLowerCase().indexOf("javascript:") === 0
+			) {
+				context.report({ node, messageId: "unexpectedScriptURL" });
+			}
+		}
+		return {
+			Literal(node) {
+				if (node.value && typeof node.value === "string") {
+					check(node);
+				}
+			},
+			TemplateLiteral(node) {
+				if (
+					!(
+						node.parent &&
+						node.parent.type === "TaggedTemplateExpression"
+					)
+				) {
+					check(node);
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-self-assign.js

@@ -0,0 +1,186 @@
+/**
+ * @fileoverview Rule to disallow assignments where both sides are exactly the same
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const SPACES = /\s+/gu;
+
+/**
+ * Traverses 2 Pattern nodes in parallel, then reports self-assignments.
+ * @param {ASTNode|null} left A left node to traverse. This is a Pattern or
+ *      a Property.
+ * @param {ASTNode|null} right A right node to traverse. This is a Pattern or
+ *      a Property.
+ * @param {boolean} props The flag to check member expressions as well.
+ * @param {Function} report A callback function to report.
+ * @returns {void}
+ */
+function eachSelfAssignment(left, right, props, report) {
+	if (!left || !right) {
+		// do nothing
+	} else if (
+		left.type === "Identifier" &&
+		right.type === "Identifier" &&
+		left.name === right.name
+	) {
+		report(right);
+	} else if (
+		left.type === "ArrayPattern" &&
+		right.type === "ArrayExpression"
+	) {
+		const end = Math.min(left.elements.length, right.elements.length);
+
+		for (let i = 0; i < end; ++i) {
+			const leftElement = left.elements[i];
+			const rightElement = right.elements[i];
+
+			// Avoid cases such as [...a] = [...a, 1]
+			if (
+				leftElement &&
+				leftElement.type === "RestElement" &&
+				i < right.elements.length - 1
+			) {
+				break;
+			}
+
+			eachSelfAssignment(leftElement, rightElement, props, report);
+
+			// After a spread element, those indices are unknown.
+			if (rightElement && rightElement.type === "SpreadElement") {
+				break;
+			}
+		}
+	} else if (left.type === "RestElement" && right.type === "SpreadElement") {
+		eachSelfAssignment(left.argument, right.argument, props, report);
+	} else if (
+		left.type === "ObjectPattern" &&
+		right.type === "ObjectExpression" &&
+		right.properties.length >= 1
+	) {
+		/*
+		 * Gets the index of the last spread property.
+		 * It's possible to overwrite properties followed by it.
+		 */
+		let startJ = 0;
+
+		for (let i = right.properties.length - 1; i >= 0; --i) {
+			const propType = right.properties[i].type;
+
+			if (
+				propType === "SpreadElement" ||
+				propType === "ExperimentalSpreadProperty"
+			) {
+				startJ = i + 1;
+				break;
+			}
+		}
+
+		for (let i = 0; i < left.properties.length; ++i) {
+			for (let j = startJ; j < right.properties.length; ++j) {
+				eachSelfAssignment(
+					left.properties[i],
+					right.properties[j],
+					props,
+					report,
+				);
+			}
+		}
+	} else if (
+		left.type === "Property" &&
+		right.type === "Property" &&
+		right.kind === "init" &&
+		!right.method
+	) {
+		const leftName = astUtils.getStaticPropertyName(left);
+
+		if (
+			leftName !== null &&
+			leftName === astUtils.getStaticPropertyName(right)
+		) {
+			eachSelfAssignment(left.value, right.value, props, report);
+		}
+	} else if (
+		props &&
+		astUtils.skipChainExpression(left).type === "MemberExpression" &&
+		astUtils.skipChainExpression(right).type === "MemberExpression" &&
+		astUtils.isSameReference(left, right)
+	) {
+		report(right);
+	}
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		defaultOptions: [{ props: true }],
+
+		docs: {
+			description:
+				"Disallow assignments where both sides are exactly the same",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-self-assign",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					props: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			selfAssignment: "'{{name}}' is assigned to itself.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const [{ props }] = context.options;
+
+		/**
+		 * Reports a given node as self assignments.
+		 * @param {ASTNode} node A node to report. This is an Identifier node.
+		 * @returns {void}
+		 */
+		function report(node) {
+			context.report({
+				node,
+				messageId: "selfAssignment",
+				data: {
+					name: sourceCode.getText(node).replace(SPACES, ""),
+				},
+			});
+		}
+
+		return {
+			AssignmentExpression(node) {
+				if (["=", "&&=", "||=", "??="].includes(node.operator)) {
+					eachSelfAssignment(node.left, node.right, props, report);
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-self-compare.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Rule to flag comparison where left part is the same as the right
+ * part.
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow comparisons where both sides are exactly the same",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-self-compare",
+		},
+
+		schema: [],
+
+		messages: {
+			comparingToSelf: "Comparing to itself is potentially pointless.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Determines whether two nodes are composed of the same tokens.
+		 * @param {ASTNode} nodeA The first node
+		 * @param {ASTNode} nodeB The second node
+		 * @returns {boolean} true if the nodes have identical token representations
+		 */
+		function hasSameTokens(nodeA, nodeB) {
+			const tokensA = sourceCode.getTokens(nodeA);
+			const tokensB = sourceCode.getTokens(nodeB);
+
+			return (
+				tokensA.length === tokensB.length &&
+				tokensA.every(
+					(token, index) =>
+						token.type === tokensB[index].type &&
+						token.value === tokensB[index].value,
+				)
+			);
+		}
+
+		return {
+			BinaryExpression(node) {
+				const operators = new Set([
+					"===",
+					"==",
+					"!==",
+					"!=",
+					">",
+					"<",
+					">=",
+					"<=",
+				]);
+
+				if (
+					operators.has(node.operator) &&
+					hasSameTokens(node.left, node.right)
+				) {
+					context.report({ node, messageId: "comparingToSelf" });
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-sequences.js

@@ -0,0 +1,158 @@
+/**
+ * @fileoverview Rule to flag use of comma operator
+ * @author Brandon Mills
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow comma operators",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-sequences",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowInParentheses: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		defaultOptions: [
+			{
+				allowInParentheses: true,
+			},
+		],
+
+		messages: {
+			unexpectedCommaExpression: "Unexpected use of comma operator.",
+		},
+	},
+
+	create(context) {
+		const [{ allowInParentheses }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Parts of the grammar that are required to have parens.
+		 */
+		const parenthesized = {
+			DoWhileStatement: "test",
+			IfStatement: "test",
+			SwitchStatement: "discriminant",
+			WhileStatement: "test",
+			WithStatement: "object",
+			ArrowFunctionExpression: "body",
+
+			/*
+			 * Omitting CallExpression - commas are parsed as argument separators
+			 * Omitting NewExpression - commas are parsed as argument separators
+			 * Omitting ForInStatement - parts aren't individually parenthesised
+			 * Omitting ForStatement - parts aren't individually parenthesised
+			 */
+		};
+
+		/**
+		 * Determines whether a node is required by the grammar to be wrapped in
+		 * parens, e.g. the test of an if statement.
+		 * @param {ASTNode} node The AST node
+		 * @returns {boolean} True if parens around node belong to parent node.
+		 */
+		function requiresExtraParens(node) {
+			return (
+				node.parent &&
+				parenthesized[node.parent.type] &&
+				node === node.parent[parenthesized[node.parent.type]]
+			);
+		}
+
+		/**
+		 * Check if a node is wrapped in parens.
+		 * @param {ASTNode} node The AST node
+		 * @returns {boolean} True if the node has a paren on each side.
+		 */
+		function isParenthesised(node) {
+			return astUtils.isParenthesised(sourceCode, node);
+		}
+
+		/**
+		 * Check if a node is wrapped in two levels of parens.
+		 * @param {ASTNode} node The AST node
+		 * @returns {boolean} True if two parens surround the node on each side.
+		 */
+		function isParenthesisedTwice(node) {
+			const previousToken = sourceCode.getTokenBefore(node, 1),
+				nextToken = sourceCode.getTokenAfter(node, 1);
+
+			return (
+				isParenthesised(node) &&
+				previousToken &&
+				nextToken &&
+				astUtils.isOpeningParenToken(previousToken) &&
+				previousToken.range[1] <= node.range[0] &&
+				astUtils.isClosingParenToken(nextToken) &&
+				nextToken.range[0] >= node.range[1]
+			);
+		}
+
+		return {
+			SequenceExpression(node) {
+				// Always allow sequences in for statement update
+				if (
+					node.parent.type === "ForStatement" &&
+					(node === node.parent.init || node === node.parent.update)
+				) {
+					return;
+				}
+
+				// Wrapping a sequence in extra parens indicates intent
+				if (allowInParentheses) {
+					if (requiresExtraParens(node)) {
+						if (isParenthesisedTwice(node)) {
+							return;
+						}
+					} else {
+						if (isParenthesised(node)) {
+							return;
+						}
+					}
+				}
+
+				const firstCommaToken = sourceCode.getTokenAfter(
+					node.expressions[0],
+					astUtils.isCommaToken,
+				);
+
+				context.report({
+					node,
+					loc: firstCommaToken.loc,
+					messageId: "unexpectedCommaExpression",
+				});
+			},
+		};
+	},
+};