bahlint 28.58.6934

package/lib/rules/no-useless-backreference.js

@@ -0,0 +1,263 @@
+/**
+ * @fileoverview Rule to disallow useless backreferences in regular expressions
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const {
+	CALL,
+	CONSTRUCT,
+	ReferenceTracker,
+	getStringIfConstant,
+} = require("@eslint-community/eslint-utils");
+const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const parser = new RegExpParser();
+
+/**
+ * Finds the path from the given `regexpp` AST node to the root node.
+ * @param {regexpp.Node} node Node.
+ * @returns {regexpp.Node[]} Array that starts with the given node and ends with the root node.
+ */
+function getPathToRoot(node) {
+	const path = [];
+	let current = node;
+
+	do {
+		path.push(current);
+		current = current.parent;
+	} while (current);
+
+	return path;
+}
+
+/**
+ * Determines whether the given `regexpp` AST node is a lookaround node.
+ * @param {regexpp.Node} node Node.
+ * @returns {boolean} `true` if it is a lookaround node.
+ */
+function isLookaround(node) {
+	return (
+		node.type === "Assertion" &&
+		(node.kind === "lookahead" || node.kind === "lookbehind")
+	);
+}
+
+/**
+ * Determines whether the given `regexpp` AST node is a negative lookaround node.
+ * @param {regexpp.Node} node Node.
+ * @returns {boolean} `true` if it is a negative lookaround node.
+ */
+function isNegativeLookaround(node) {
+	return isLookaround(node) && node.negate;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow useless backreferences in regular expressions",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-useless-backreference",
+		},
+
+		schema: [],
+
+		messages: {
+			nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} from within that group.",
+			forward:
+				"Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears later in the pattern.",
+			backward:
+				"Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which appears before in the same lookbehind.",
+			disjunctive:
+				"Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in another alternative.",
+			intoNegativeLookaround:
+				"Backreference '{{ bref }}' will be ignored. It references group '{{ group }}'{{ otherGroups }} which is in a negative lookaround.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Checks and reports useless backreferences in the given regular expression.
+		 * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call.
+		 * @param {string} pattern Regular expression pattern.
+		 * @param {string} flags Regular expression flags.
+		 * @returns {void}
+		 */
+		function checkRegex(node, pattern, flags) {
+			let regExpAST;
+
+			try {
+				regExpAST = parser.parsePattern(pattern, 0, pattern.length, {
+					unicode: flags.includes("u"),
+					unicodeSets: flags.includes("v"),
+				});
+			} catch {
+				// Ignore regular expressions with syntax errors
+				return;
+			}
+
+			visitRegExpAST(regExpAST, {
+				onBackreferenceEnter(bref) {
+					const groups = [bref.resolved].flat(),
+						brefPath = getPathToRoot(bref);
+
+					const problems = groups.map(group => {
+						const groupPath = getPathToRoot(group);
+
+						if (brefPath.includes(group)) {
+							// group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match.
+							return {
+								messageId: "nested",
+								group,
+							};
+						}
+
+						// Start from the root to find the lowest common ancestor.
+						let i = brefPath.length - 1,
+							j = groupPath.length - 1;
+
+						do {
+							i--;
+							j--;
+						} while (brefPath[i] === groupPath[j]);
+
+						const indexOfLowestCommonAncestor = j + 1,
+							groupCut = groupPath.slice(
+								0,
+								indexOfLowestCommonAncestor,
+							),
+							commonPath = groupPath.slice(
+								indexOfLowestCommonAncestor,
+							),
+							lowestCommonLookaround =
+								commonPath.find(isLookaround),
+							isMatchingBackward =
+								lowestCommonLookaround &&
+								lowestCommonLookaround.kind === "lookbehind";
+
+						if (groupCut.at(-1).type === "Alternative") {
+							// group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
+							return {
+								messageId: "disjunctive",
+								group,
+							};
+						}
+						if (!isMatchingBackward && bref.end <= group.start) {
+							// bref is left, group is right ('forward reference') => group hasn't matched yet when bref starts to match.
+							return {
+								messageId: "forward",
+								group,
+							};
+						}
+						if (isMatchingBackward && group.end <= bref.start) {
+							// the opposite of the previous when the regex is matching backward in a lookbehind context.
+							return {
+								messageId: "backward",
+								group,
+							};
+						}
+						if (groupCut.some(isNegativeLookaround)) {
+							// group is in a negative lookaround which isn't bref's ancestor => group has already failed when bref starts to match.
+							return {
+								messageId: "intoNegativeLookaround",
+								group,
+							};
+						}
+
+						return null;
+					});
+
+					if (
+						problems.length === 0 ||
+						problems.some(problem => !problem)
+					) {
+						// If there are no problems or no problems with any group then do not report it.
+						return;
+					}
+
+					let problemsToReport;
+
+					// Gets problems that appear in the same disjunction.
+					const problemsInSameDisjunction = problems.filter(
+						problem => problem.messageId !== "disjunctive",
+					);
+
+					if (problemsInSameDisjunction.length) {
+						// Only report problems that appear in the same disjunction.
+						problemsToReport = problemsInSameDisjunction;
+					} else {
+						// If all groups appear in different disjunctions, report it.
+						problemsToReport = problems;
+					}
+
+					const [{ messageId, group }, ...other] = problemsToReport;
+					let otherGroups = "";
+
+					if (other.length === 1) {
+						otherGroups = " and another group";
+					} else if (other.length > 1) {
+						otherGroups = ` and other ${other.length} groups`;
+					}
+					context.report({
+						node,
+						messageId,
+						data: {
+							bref: bref.raw,
+							group: group.raw,
+							otherGroups,
+						},
+					});
+				},
+			});
+		}
+
+		return {
+			"Literal[regex]"(node) {
+				const { pattern, flags } = node.regex;
+
+				checkRegex(node, pattern, flags);
+			},
+			Program(node) {
+				const scope = sourceCode.getScope(node),
+					tracker = new ReferenceTracker(scope),
+					traceMap = {
+						RegExp: {
+							[CALL]: true,
+							[CONSTRUCT]: true,
+						},
+					};
+
+				for (const { node: refNode } of tracker.iterateGlobalReferences(
+					traceMap,
+				)) {
+					const [patternNode, flagsNode] = refNode.arguments,
+						pattern = getStringIfConstant(patternNode, scope),
+						flags = getStringIfConstant(flagsNode, scope);
+
+					if (typeof pattern === "string") {
+						checkRegex(refNode, pattern, flags || "");
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-useless-call.js

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview A rule to disallow unnecessary `.call()` and `.apply()`.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether or not a node is a `.call()`/`.apply()`.
+ * @param {ASTNode} node A CallExpression node to check.
+ * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
+ */
+function isCallOrNonVariadicApply(node) {
+	const callee = astUtils.skipChainExpression(node.callee);
+
+	return (
+		callee.type === "MemberExpression" &&
+		callee.property.type === "Identifier" &&
+		callee.computed === false &&
+		((callee.property.name === "call" && node.arguments.length >= 1) ||
+			(callee.property.name === "apply" &&
+				node.arguments.length === 2 &&
+				node.arguments[1].type === "ArrayExpression"))
+	);
+}
+
+/**
+ * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.
+ * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
+ * @param {ASTNode} thisArg The node that is given to the first argument of the `.call()`/`.apply()`.
+ * @param {SourceCode} sourceCode The ESLint source code object.
+ * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.
+ */
+function isValidThisArg(expectedThis, thisArg, sourceCode) {
+	if (!expectedThis) {
+		return astUtils.isNullOrUndefined(thisArg);
+	}
+	return astUtils.equalTokens(expectedThis, thisArg, sourceCode);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow unnecessary calls to `.call()` and `.apply()`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-useless-call",
+		},
+
+		schema: [],
+
+		messages: {
+			unnecessaryCall: "Unnecessary '.{{name}}()'.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			CallExpression(node) {
+				if (!isCallOrNonVariadicApply(node)) {
+					return;
+				}
+
+				const callee = astUtils.skipChainExpression(node.callee);
+				const applied = astUtils.skipChainExpression(callee.object);
+				const expectedThis =
+					applied.type === "MemberExpression" ? applied.object : null;
+				const thisArg = node.arguments[0];
+
+				if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
+					context.report({
+						node,
+						messageId: "unnecessaryCall",
+						data: { name: callee.property.name },
+					});
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-useless-catch.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Reports useless `catch` clauses that just rethrow their error.
+ * @author Teddy Katz
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow unnecessary `catch` clauses",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-useless-catch",
+		},
+
+		schema: [],
+
+		messages: {
+			unnecessaryCatchClause: "Unnecessary catch clause.",
+			unnecessaryCatch: "Unnecessary try/catch wrapper.",
+		},
+	},
+
+	create(context) {
+		return {
+			CatchClause(node) {
+				if (
+					node.param &&
+					node.param.type === "Identifier" &&
+					node.body.body.length &&
+					node.body.body[0].type === "ThrowStatement" &&
+					node.body.body[0].argument.type === "Identifier" &&
+					node.body.body[0].argument.name === node.param.name
+				) {
+					if (node.parent.finalizer) {
+						context.report({
+							node,
+							messageId: "unnecessaryCatchClause",
+						});
+					} else {
+						context.report({
+							node: node.parent,
+							messageId: "unnecessaryCatch",
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/no-useless-computed-key.js

@@ -0,0 +1,204 @@
+/**
+ * @fileoverview Rule to disallow unnecessary computed property keys in object literals
+ * @author Burak Yigit Kaya
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the computed key syntax is unnecessarily used for the given node.
+ * In particular, it determines whether removing the square brackets and using the content between them
+ * directly as the key (e.g. ['foo'] -> 'foo') would produce valid syntax and preserve the same behavior.
+ * Valid non-computed keys are only: identifiers, number literals and string literals.
+ * Only literals can preserve the same behavior, with a few exceptions for specific node types:
+ * Property
+ *   - { ["__proto__"]: foo } defines a property named "__proto__"
+ *     { "__proto__": foo } defines object's prototype
+ * PropertyDefinition
+ *   - class C { ["constructor"]; } defines an instance field named "constructor"
+ *     class C { "constructor"; } produces a parsing error
+ *   - class C { static ["constructor"]; } defines a static field named "constructor"
+ *     class C { static "constructor"; } produces a parsing error
+ *   - class C { static ["prototype"]; } produces a runtime error (doesn't break the whole script)
+ *     class C { static "prototype"; } produces a parsing error (breaks the whole script)
+ * MethodDefinition
+ *   - class C { ["constructor"]() {} } defines a prototype method named "constructor"
+ *     class C { "constructor"() {} } defines the constructor
+ *   - class C { static ["prototype"]() {} } produces a runtime error (doesn't break the whole script)
+ *     class C { static "prototype"() {} } produces a parsing error (breaks the whole script)
+ * @param {ASTNode} node The node to check. It can be `Property`, `PropertyDefinition` or `MethodDefinition`.
+ * @throws {Error} (Unreachable.)
+ * @returns {void} `true` if the node has useless computed key.
+ */
+function hasUselessComputedKey(node) {
+	if (!node.computed) {
+		return false;
+	}
+
+	const { key } = node;
+
+	if (key.type !== "Literal") {
+		return false;
+	}
+
+	const { value } = key;
+
+	if (typeof value !== "number" && typeof value !== "string") {
+		return false;
+	}
+
+	switch (node.type) {
+		case "Property":
+			if (node.parent.type === "ObjectExpression") {
+				return value !== "__proto__";
+			}
+			return true;
+
+		case "PropertyDefinition":
+			if (node.static) {
+				return value !== "constructor" && value !== "prototype";
+			}
+
+			return value !== "constructor";
+
+		case "MethodDefinition":
+			if (node.static) {
+				return value !== "prototype";
+			}
+
+			return value !== "constructor";
+
+		/* c8 ignore next */
+		default:
+			throw new Error(`Unexpected node type: ${node.type}`);
+	}
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				enforceForClassMembers: true,
+			},
+		],
+
+		docs: {
+			description:
+				"Disallow unnecessary computed property keys in objects and classes",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-useless-computed-key",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					enforceForClassMembers: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+		fixable: "code",
+
+		messages: {
+			unnecessarilyComputedProperty:
+				"Unnecessarily computed property [{{property}}] found.",
+		},
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const [{ enforceForClassMembers }] = context.options;
+
+		/**
+		 * Reports a given node if it violated this rule.
+		 * @param {ASTNode} node The node to check.
+		 * @returns {void}
+		 */
+		function check(node) {
+			if (hasUselessComputedKey(node)) {
+				const { key } = node;
+
+				context.report({
+					node,
+					messageId: "unnecessarilyComputedProperty",
+					data: { property: sourceCode.getText(key) },
+					fix(fixer) {
+						const leftSquareBracket = sourceCode.getTokenBefore(
+							key,
+							astUtils.isOpeningBracketToken,
+						);
+						const rightSquareBracket = sourceCode.getTokenAfter(
+							key,
+							astUtils.isClosingBracketToken,
+						);
+
+						// If there are comments between the brackets and the property name, don't do a fix.
+						if (
+							sourceCode.commentsExistBetween(
+								leftSquareBracket,
+								rightSquareBracket,
+							)
+						) {
+							return null;
+						}
+
+						const tokenBeforeLeftBracket =
+							sourceCode.getTokenBefore(leftSquareBracket);
+
+						// Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })
+						const needsSpaceBeforeKey =
+							tokenBeforeLeftBracket.range[1] ===
+								leftSquareBracket.range[0] &&
+							!astUtils.canTokensBeAdjacent(
+								tokenBeforeLeftBracket,
+								sourceCode.getFirstToken(key),
+							);
+
+						const replacementKey =
+							(needsSpaceBeforeKey ? " " : "") + key.raw;
+
+						return fixer.replaceTextRange(
+							[
+								leftSquareBracket.range[0],
+								rightSquareBracket.range[1],
+							],
+							replacementKey,
+						);
+					},
+				});
+			}
+		}
+
+		/**
+		 * A no-op function to act as placeholder for checking a node when the `enforceForClassMembers` option is `false`.
+		 * @returns {void}
+		 * @private
+		 */
+		function noop() {}
+
+		return {
+			Property: check,
+			MethodDefinition: enforceForClassMembers ? check : noop,
+			PropertyDefinition: enforceForClassMembers ? check : noop,
+		};
+	},
+};