bahlint 28.58.6934

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

@@ -0,0 +1,450 @@
+/**
+ * @fileoverview Rule to flag `else` after a `return` in `if`
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const FixTracker = require("./utils/fix-tracker");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [{ allowElseIf: true }],
+
+		docs: {
+			description:
+				"Disallow `else` blocks after `return` statements in `if` statements",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-else-return",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowElseIf: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		fixable: "code",
+
+		messages: {
+			unexpected: "Unnecessary 'else' after 'return'.",
+		},
+	},
+
+	create(context) {
+		const [{ allowElseIf }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Checks whether the given names can be safely used to declare block-scoped variables
+		 * in the given scope. Name collisions can produce redeclaration syntax errors,
+		 * or silently change references and modify behavior of the original code.
+		 *
+		 * This is not a generic function. In particular, it is assumed that the scope is a function scope or
+		 * a function's inner scope, and that the names can be valid identifiers in the given scope.
+		 * @param {string[]} names Array of variable names.
+		 * @param {eslint-scope.Scope} scope Function scope or a function's inner scope.
+		 * @returns {boolean} True if all names can be safely declared, false otherwise.
+		 */
+		function isSafeToDeclare(names, scope) {
+			if (names.length === 0) {
+				return true;
+			}
+
+			const functionScope = scope.variableScope;
+
+			/*
+			 * If this is a function scope, scope.variables will contain parameters, implicit variables such as "arguments",
+			 * all function-scoped variables ('var'), and block-scoped variables defined in the scope.
+			 * If this is an inner scope, scope.variables will contain block-scoped variables defined in the scope.
+			 *
+			 * Redeclaring any of these would cause a syntax error, except for the implicit variables.
+			 */
+			const declaredVariables = scope.variables.filter(
+				({ defs }) => defs.length > 0,
+			);
+
+			if (declaredVariables.some(({ name }) => names.includes(name))) {
+				return false;
+			}
+
+			// Redeclaring a catch variable would also cause a syntax error.
+			if (scope !== functionScope && scope.upper.type === "catch") {
+				if (
+					scope.upper.variables.some(({ name }) =>
+						names.includes(name),
+					)
+				) {
+					return false;
+				}
+			}
+
+			/*
+			 * Redeclaring an implicit variable, such as "arguments", would not cause a syntax error.
+			 * However, if the variable was used, declaring a new one with the same name would change references
+			 * and modify behavior.
+			 */
+			const usedImplicitVariables = scope.variables.filter(
+				({ defs, references }) =>
+					defs.length === 0 && references.length > 0,
+			);
+
+			if (
+				usedImplicitVariables.some(({ name }) => names.includes(name))
+			) {
+				return false;
+			}
+
+			/*
+			 * Declaring a variable with a name that was already used to reference a variable from an upper scope
+			 * would change references and modify behavior.
+			 */
+			if (scope.through.some(t => names.includes(t.identifier.name))) {
+				return false;
+			}
+
+			/*
+			 * If the scope is an inner scope (not the function scope), an uninitialized `var` variable declared inside
+			 * the scope node (directly or in one of its descendants) is neither declared nor 'through' in the scope.
+			 *
+			 * For example, this would be a syntax error "Identifier 'a' has already been declared":
+			 * function foo() { if (bar) { let a; if (baz) { var a; } } }
+			 */
+			if (scope !== functionScope) {
+				const scopeNodeRange = scope.block.range;
+				const variablesToCheck = functionScope.variables.filter(
+					({ name }) => names.includes(name),
+				);
+
+				if (
+					variablesToCheck.some(v =>
+						v.defs.some(
+							({ node: { range } }) =>
+								scopeNodeRange[0] <= range[0] &&
+								range[1] <= scopeNodeRange[1],
+						),
+					)
+				) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		/**
+		 * Checks whether the removal of `else` and its braces is safe from variable name collisions.
+		 * @param {Node} node The 'else' node.
+		 * @param {eslint-scope.Scope} scope The scope in which the node and the whole 'if' statement is.
+		 * @returns {boolean} True if it is safe, false otherwise.
+		 */
+		function isSafeFromNameCollisions(node, scope) {
+			if (node.type === "FunctionDeclaration") {
+				// Conditional function declaration. Scope and hoisting are unpredictable, different engines work differently.
+				return false;
+			}
+
+			if (node.type !== "BlockStatement") {
+				return true;
+			}
+
+			const elseBlockScope = scope.childScopes.find(
+				({ block }) => block === node,
+			);
+
+			if (!elseBlockScope) {
+				// ecmaVersion < 6, `else` block statement cannot have its own scope, no possible collisions.
+				return true;
+			}
+
+			/*
+			 * elseBlockScope is supposed to merge into its upper scope. elseBlockScope.variables array contains
+			 * only block-scoped variables (such as let and const variables or class and function declarations)
+			 * defined directly in the elseBlockScope. These are exactly the only names that could cause collisions.
+			 */
+			const namesToCheck = elseBlockScope.variables.map(
+				({ name }) => name,
+			);
+
+			return isSafeToDeclare(namesToCheck, scope);
+		}
+
+		/**
+		 * Display the context report if rule is violated
+		 * @param {Node} elseNode The 'else' node
+		 * @returns {void}
+		 */
+		function displayReport(elseNode) {
+			const currentScope = sourceCode.getScope(elseNode.parent);
+
+			context.report({
+				node: elseNode,
+				messageId: "unexpected",
+				fix(fixer) {
+					if (!isSafeFromNameCollisions(elseNode, currentScope)) {
+						return null;
+					}
+
+					const startToken = sourceCode.getFirstToken(elseNode);
+					const elseToken = sourceCode.getTokenBefore(startToken);
+					const source = sourceCode.getText(elseNode);
+					const lastIfToken = sourceCode.getTokenBefore(elseToken);
+					let fixedSource, firstTokenOfElseBlock;
+
+					if (
+						startToken.type === "Punctuator" &&
+						startToken.value === "{"
+					) {
+						firstTokenOfElseBlock =
+							sourceCode.getTokenAfter(startToken);
+					} else {
+						firstTokenOfElseBlock = startToken;
+					}
+
+					/*
+					 * If the if block does not have curly braces and does not end in a semicolon
+					 * and the else block starts with (, [, /, +, ` or -, then it is not
+					 * safe to remove the else keyword, because ASI will not add a semicolon
+					 * after the if block
+					 */
+					const ifBlockMaybeUnsafe =
+						elseNode.parent.consequent.type !== "BlockStatement" &&
+						lastIfToken.value !== ";";
+					const elseBlockUnsafe = /^[([/+`-]/u.test(
+						firstTokenOfElseBlock.value,
+					);
+
+					if (ifBlockMaybeUnsafe && elseBlockUnsafe) {
+						return null;
+					}
+
+					const endToken = sourceCode.getLastToken(elseNode);
+					const lastTokenOfElseBlock =
+						sourceCode.getTokenBefore(endToken);
+
+					if (lastTokenOfElseBlock.value !== ";") {
+						const nextToken = sourceCode.getTokenAfter(endToken);
+
+						const nextTokenUnsafe =
+							nextToken && /^[([/+`-]/u.test(nextToken.value);
+						const nextTokenOnSameLine =
+							nextToken &&
+							nextToken.loc.start.line ===
+								lastTokenOfElseBlock.loc.start.line;
+
+						/*
+						 * If the else block contents does not end in a semicolon,
+						 * and the else block starts with (, [, /, +, ` or -, then it is not
+						 * safe to remove the else block, because ASI will not add a semicolon
+						 * after the remaining else block contents
+						 */
+						if (
+							nextTokenUnsafe ||
+							(nextTokenOnSameLine && nextToken.value !== "}")
+						) {
+							return null;
+						}
+					}
+
+					if (
+						startToken.type === "Punctuator" &&
+						startToken.value === "{"
+					) {
+						fixedSource = source.slice(1, -1);
+					} else {
+						fixedSource = source;
+					}
+
+					/*
+					 * Extend the replacement range to include the entire
+					 * function to avoid conflicting with no-useless-return.
+					 * https://github.com/eslint/eslint/issues/8026
+					 *
+					 * Also, to avoid name collisions between two else blocks.
+					 */
+					return new FixTracker(fixer, sourceCode)
+						.retainEnclosingFunction(elseNode)
+						.replaceTextRange(
+							[elseToken.range[0], elseNode.range[1]],
+							fixedSource,
+						);
+				},
+			});
+		}
+
+		/**
+		 * Check to see if the node is a ReturnStatement
+		 * @param {Node} node The node being evaluated
+		 * @returns {boolean} True if node is a return
+		 */
+		function checkForReturn(node) {
+			return node.type === "ReturnStatement";
+		}
+
+		/**
+		 * Naive return checking, does not iterate through the whole
+		 * BlockStatement because we make the assumption that the ReturnStatement
+		 * will be the last node in the body of the BlockStatement.
+		 * @param {Node} node The consequent/alternate node
+		 * @returns {boolean} True if it has a return
+		 */
+		function naiveHasReturn(node) {
+			if (node.type === "BlockStatement") {
+				const body = node.body,
+					lastChildNode = body.at(-1);
+
+				return lastChildNode && checkForReturn(lastChildNode);
+			}
+			return checkForReturn(node);
+		}
+
+		/**
+		 * Check to see if the node is valid for evaluation,
+		 * meaning it has an else.
+		 * @param {Node} node The node being evaluated
+		 * @returns {boolean} True if the node is valid
+		 */
+		function hasElse(node) {
+			return node.alternate && node.consequent;
+		}
+
+		/**
+		 * If the consequent is an IfStatement, check to see if it has an else
+		 * and both its consequent and alternate path return, meaning this is
+		 * a nested case of rule violation.  If-Else not considered currently.
+		 * @param {Node} node The consequent node
+		 * @returns {boolean} True if this is a nested rule violation
+		 */
+		function checkForIf(node) {
+			return (
+				node.type === "IfStatement" &&
+				hasElse(node) &&
+				naiveHasReturn(node.alternate) &&
+				naiveHasReturn(node.consequent)
+			);
+		}
+
+		/**
+		 * Check the consequent/body node to make sure it is not
+		 * a ReturnStatement or an IfStatement that returns on both
+		 * code paths.
+		 * @param {Node} node The consequent or body node
+		 * @returns {boolean} `true` if it is a Return/If node that always returns.
+		 */
+		function checkForReturnOrIf(node) {
+			return checkForReturn(node) || checkForIf(node);
+		}
+
+		/**
+		 * Check whether a node returns in every codepath.
+		 * @param {Node} node The node to be checked
+		 * @returns {boolean} `true` if it returns on every codepath.
+		 */
+		function alwaysReturns(node) {
+			if (node.type === "BlockStatement") {
+				// If we have a BlockStatement, check each consequent body node.
+				return node.body.some(checkForReturnOrIf);
+			}
+
+			/*
+			 * If not a block statement, make sure the consequent isn't a
+			 * ReturnStatement or an IfStatement with returns on both paths.
+			 */
+			return checkForReturnOrIf(node);
+		}
+
+		/**
+		 * Check the if statement, but don't catch else-if blocks.
+		 * @returns {void}
+		 * @param {Node} node The node for the if statement to check
+		 * @private
+		 */
+		function checkIfWithoutElse(node) {
+			const parent = node.parent;
+
+			/*
+			 * Fixing this would require splitting one statement into two, so no error should
+			 * be reported if this node is in a position where only one statement is allowed.
+			 */
+			if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) {
+				return;
+			}
+
+			const consequents = [];
+			let alternate;
+
+			for (
+				let currentNode = node;
+				currentNode.type === "IfStatement";
+				currentNode = currentNode.alternate
+			) {
+				if (!currentNode.alternate) {
+					return;
+				}
+				consequents.push(currentNode.consequent);
+				alternate = currentNode.alternate;
+			}
+
+			if (consequents.every(alwaysReturns)) {
+				displayReport(alternate);
+			}
+		}
+
+		/**
+		 * Check the if statement
+		 * @returns {void}
+		 * @param {Node} node The node for the if statement to check
+		 * @private
+		 */
+		function checkIfWithElse(node) {
+			const parent = node.parent;
+
+			/*
+			 * Fixing this would require splitting one statement into two, so no error should
+			 * be reported if this node is in a position where only one statement is allowed.
+			 */
+			if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) {
+				return;
+			}
+
+			const alternate = node.alternate;
+
+			if (alternate && alwaysReturns(node.consequent)) {
+				displayReport(alternate);
+			}
+		}
+
+		//--------------------------------------------------------------------------
+		// Public API
+		//--------------------------------------------------------------------------
+
+		return {
+			"IfStatement:exit": allowElseIf
+				? checkIfWithoutElse
+				: checkIfWithElse,
+		};
+	},
+};

package/lib/rules/no-empty-character-class.js

@@ -0,0 +1,83 @@
+/**
+ * @fileoverview Rule to flag the use of empty character classes in regular expressions
+ * @author Ian Christian Myers
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const parser = new RegExpParser();
+const QUICK_TEST_REGEX = /\[\]/u;
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow empty character classes in regular expressions",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-empty-character-class",
+		},
+
+		schema: [],
+
+		messages: {
+			unexpected: "Empty class.",
+		},
+	},
+
+	create(context) {
+		return {
+			"Literal[regex]"(node) {
+				const { pattern, flags } = node.regex;
+
+				if (!QUICK_TEST_REGEX.test(pattern)) {
+					return;
+				}
+
+				let regExpAST;
+
+				try {
+					regExpAST = parser.parsePattern(
+						pattern,
+						0,
+						pattern.length,
+						{
+							unicode: flags.includes("u"),
+							unicodeSets: flags.includes("v"),
+						},
+					);
+				} catch {
+					// Ignore regular expressions that regexpp cannot parse
+					return;
+				}
+
+				visitRegExpAST(regExpAST, {
+					onCharacterClassEnter(characterClass) {
+						if (
+							!characterClass.negate &&
+							characterClass.elements.length === 0
+						) {
+							context.report({ node, messageId: "unexpected" });
+						}
+					},
+				});
+			},
+		};
+	},
+};