bahlint 28.58.6934-dev-001

package/lib/rules/prefer-regex-literals.js

@@ -0,0 +1,605 @@
+/**
+ * @fileoverview Rule to disallow use of the `RegExp` constructor in favor of regular expression literals
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const {
+	CALL,
+	CONSTRUCT,
+	ReferenceTracker,
+} = require("@eslint-community/eslint-utils");
+const {
+	RegExpValidator,
+	visitRegExpAST,
+	RegExpParser,
+} = require("@eslint-community/regexpp");
+const { canTokensBeAdjacent } = require("./utils/ast-utils");
+const { REGEXPP_LATEST_ECMA_VERSION } = require("./utils/regular-expressions");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the given node is a string literal.
+ * @param {ASTNode} node Node to check.
+ * @returns {boolean} True if the node is a string literal.
+ */
+function isStringLiteral(node) {
+	return node.type === "Literal" && typeof node.value === "string";
+}
+
+/**
+ * Determines whether the given node is a regex literal.
+ * @param {ASTNode} node Node to check.
+ * @returns {boolean} True if the node is a regex literal.
+ */
+function isRegexLiteral(node) {
+	return node.type === "Literal" && Object.hasOwn(node, "regex");
+}
+
+const validPrecedingTokens = new Set([
+	"(",
+	";",
+	"[",
+	",",
+	"=",
+	"+",
+	"*",
+	"-",
+	"?",
+	"~",
+	"%",
+	"**",
+	"!",
+	"typeof",
+	"instanceof",
+	"&&",
+	"||",
+	"??",
+	"return",
+	"...",
+	"delete",
+	"void",
+	"in",
+	"<",
+	">",
+	"<=",
+	">=",
+	"==",
+	"===",
+	"!=",
+	"!==",
+	"<<",
+	">>",
+	">>>",
+	"&",
+	"|",
+	"^",
+	":",
+	"{",
+	"=>",
+	"*=",
+	"<<=",
+	">>=",
+	">>>=",
+	"^=",
+	"|=",
+	"&=",
+	"??=",
+	"||=",
+	"&&=",
+	"**=",
+	"+=",
+	"-=",
+	"/=",
+	"%=",
+	"/",
+	"do",
+	"break",
+	"continue",
+	"debugger",
+	"case",
+	"throw",
+]);
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				disallowRedundantWrapping: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Disallow use of the `RegExp` constructor in favor of regular expression literals",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/prefer-regex-literals",
+		},
+
+		hasSuggestions: true,
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					disallowRedundantWrapping: {
+						type: "boolean",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpectedRegExp:
+				"Use a regular expression literal instead of the 'RegExp' constructor.",
+			replaceWithLiteral:
+				"Replace with an equivalent regular expression literal.",
+			replaceWithLiteralAndFlags:
+				"Replace with an equivalent regular expression literal with flags '{{ flags }}'.",
+			replaceWithIntendedLiteralAndFlags:
+				"Replace with a regular expression literal with flags '{{ flags }}'.",
+			unexpectedRedundantRegExp:
+				"Regular expression literal is unnecessarily wrapped within a 'RegExp' constructor.",
+			unexpectedRedundantRegExpWithFlags:
+				"Use regular expression literal with flags instead of the 'RegExp' constructor.",
+		},
+	},
+
+	create(context) {
+		const [{ disallowRedundantWrapping }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Determines whether the given node is a String.raw`` tagged template expression
+		 * with a static template literal.
+		 * @param {ASTNode} node Node to check.
+		 * @returns {boolean} True if the node is String.raw`` with a static template.
+		 */
+		function isStringRawTaggedStaticTemplateLiteral(node) {
+			return (
+				node.type === "TaggedTemplateExpression" &&
+				astUtils.isSpecificMemberAccess(node.tag, "String", "raw") &&
+				sourceCode.isGlobalReference(
+					astUtils.skipChainExpression(node.tag).object,
+				) &&
+				astUtils.isStaticTemplateLiteral(node.quasi)
+			);
+		}
+
+		/**
+		 * Gets the value of a string
+		 * @param {ASTNode} node The node to get the string of.
+		 * @returns {string|null} The value of the node.
+		 */
+		function getStringValue(node) {
+			if (isStringLiteral(node)) {
+				return node.value;
+			}
+
+			if (astUtils.isStaticTemplateLiteral(node)) {
+				return node.quasis[0].value.cooked;
+			}
+
+			if (isStringRawTaggedStaticTemplateLiteral(node)) {
+				return node.quasi.quasis[0].value.raw;
+			}
+
+			return null;
+		}
+
+		/**
+		 * Determines whether the given node is considered to be a static string by the logic of this rule.
+		 * @param {ASTNode} node Node to check.
+		 * @returns {boolean} True if the node is a static string.
+		 */
+		function isStaticString(node) {
+			return (
+				isStringLiteral(node) ||
+				astUtils.isStaticTemplateLiteral(node) ||
+				isStringRawTaggedStaticTemplateLiteral(node)
+			);
+		}
+
+		/**
+		 * Determines whether the relevant arguments of the given are all static string literals.
+		 * @param {ASTNode} node Node to check.
+		 * @returns {boolean} True if all arguments are static strings.
+		 */
+		function hasOnlyStaticStringArguments(node) {
+			const args = node.arguments;
+
+			if (
+				(args.length === 1 || args.length === 2) &&
+				args.every(isStaticString)
+			) {
+				return true;
+			}
+
+			return false;
+		}
+
+		/**
+		 * Determines whether the arguments of the given node indicate that a regex literal is unnecessarily wrapped.
+		 * @param {ASTNode} node Node to check.
+		 * @returns {boolean} True if the node already contains a regex literal argument.
+		 */
+		function isUnnecessarilyWrappedRegexLiteral(node) {
+			const args = node.arguments;
+
+			if (args.length === 1 && isRegexLiteral(args[0])) {
+				return true;
+			}
+
+			if (
+				args.length === 2 &&
+				isRegexLiteral(args[0]) &&
+				isStaticString(args[1])
+			) {
+				return true;
+			}
+
+			return false;
+		}
+
+		/**
+		 * Returns a ecmaVersion compatible for regexpp.
+		 * @param {number} ecmaVersion The ecmaVersion to convert.
+		 * @returns {import("@eslint-community/regexpp/ecma-versions").EcmaVersion} The resulting ecmaVersion compatible for regexpp.
+		 */
+		function getRegexppEcmaVersion(ecmaVersion) {
+			if (ecmaVersion <= 5) {
+				return 5;
+			}
+			return Math.min(ecmaVersion, REGEXPP_LATEST_ECMA_VERSION);
+		}
+
+		const regexppEcmaVersion = getRegexppEcmaVersion(
+			context.languageOptions.ecmaVersion,
+		);
+
+		/**
+		 * Makes a character escaped or else returns null.
+		 * @param {string} character The character to escape.
+		 * @returns {string} The resulting escaped character.
+		 */
+		function resolveEscapes(character) {
+			switch (character) {
+				case "\n":
+				case "\\\n":
+					return "\\n";
+
+				case "\r":
+				case "\\\r":
+					return "\\r";
+
+				case "\t":
+				case "\\\t":
+					return "\\t";
+
+				case "\v":
+				case "\\\v":
+					return "\\v";
+
+				case "\f":
+				case "\\\f":
+					return "\\f";
+
+				case "/":
+					return "\\/";
+
+				default:
+					return null;
+			}
+		}
+
+		/**
+		 * Checks whether the given regex and flags are valid for the ecma version or not.
+		 * @param {string} pattern The regex pattern to check.
+		 * @param {string | undefined} flags The regex flags to check.
+		 * @returns {boolean} True if the given regex pattern and flags are valid for the ecma version.
+		 */
+		function isValidRegexForEcmaVersion(pattern, flags) {
+			const validator = new RegExpValidator({
+				ecmaVersion: regexppEcmaVersion,
+			});
+
+			try {
+				validator.validatePattern(pattern, 0, pattern.length, {
+					unicode: flags ? flags.includes("u") : false,
+					unicodeSets: flags ? flags.includes("v") : false,
+				});
+				if (flags) {
+					validator.validateFlags(flags);
+				}
+				return true;
+			} catch {
+				return false;
+			}
+		}
+
+		/**
+		 * Checks whether two given regex flags contain the same flags or not.
+		 * @param {string} flagsA The regex flags.
+		 * @param {string} flagsB The regex flags.
+		 * @returns {boolean} True if two regex flags contain same flags.
+		 */
+		function areFlagsEqual(flagsA, flagsB) {
+			return [...flagsA].sort().join("") === [...flagsB].sort().join("");
+		}
+
+		/**
+		 * Merges two regex flags.
+		 * @param {string} flagsA The regex flags.
+		 * @param {string} flagsB The regex flags.
+		 * @returns {string} The merged regex flags.
+		 */
+		function mergeRegexFlags(flagsA, flagsB) {
+			const flagsSet = new Set([...flagsA, ...flagsB]);
+
+			return [...flagsSet].join("");
+		}
+
+		/**
+		 * Checks whether a give node can be fixed to the given regex pattern and flags.
+		 * @param {ASTNode} node The node to check.
+		 * @param {string} pattern The regex pattern to check.
+		 * @param {string} flags The regex flags
+		 * @returns {boolean} True if a node can be fixed to the given regex pattern and flags.
+		 */
+		function canFixTo(node, pattern, flags) {
+			const tokenBefore = sourceCode.getTokenBefore(node);
+
+			return (
+				sourceCode.getCommentsInside(node).length === 0 &&
+				(!tokenBefore || validPrecedingTokens.has(tokenBefore.value)) &&
+				isValidRegexForEcmaVersion(pattern, flags)
+			);
+		}
+
+		/**
+		 * Returns a safe output code considering the before and after tokens.
+		 * @param {ASTNode} node The regex node.
+		 * @param {string} newRegExpValue The new regex expression value.
+		 * @returns {string} The output code.
+		 */
+		function getSafeOutput(node, newRegExpValue) {
+			const tokenBefore = sourceCode.getTokenBefore(node);
+			const tokenAfter = sourceCode.getTokenAfter(node);
+
+			return (
+				(tokenBefore &&
+				!canTokensBeAdjacent(tokenBefore, newRegExpValue) &&
+				tokenBefore.range[1] === node.range[0]
+					? " "
+					: "") +
+				newRegExpValue +
+				(tokenAfter &&
+				!canTokensBeAdjacent(newRegExpValue, tokenAfter) &&
+				node.range[1] === tokenAfter.range[0]
+					? " "
+					: "")
+			);
+		}
+
+		return {
+			Program(node) {
+				const scope = sourceCode.getScope(node);
+				const tracker = new ReferenceTracker(scope);
+				const traceMap = {
+					RegExp: {
+						[CALL]: true,
+						[CONSTRUCT]: true,
+					},
+				};
+
+				for (const { node: refNode } of tracker.iterateGlobalReferences(
+					traceMap,
+				)) {
+					if (
+						disallowRedundantWrapping &&
+						isUnnecessarilyWrappedRegexLiteral(refNode)
+					) {
+						const regexNode = refNode.arguments[0];
+
+						if (refNode.arguments.length === 2) {
+							const suggests = [];
+
+							const argFlags =
+								getStringValue(refNode.arguments[1]) || "";
+
+							if (
+								canFixTo(
+									refNode,
+									regexNode.regex.pattern,
+									argFlags,
+								)
+							) {
+								suggests.push({
+									messageId: "replaceWithLiteralAndFlags",
+									pattern: regexNode.regex.pattern,
+									flags: argFlags,
+								});
+							}
+
+							const literalFlags = regexNode.regex.flags || "";
+							const mergedFlags = mergeRegexFlags(
+								literalFlags,
+								argFlags,
+							);
+
+							if (
+								!areFlagsEqual(mergedFlags, argFlags) &&
+								canFixTo(
+									refNode,
+									regexNode.regex.pattern,
+									mergedFlags,
+								)
+							) {
+								suggests.push({
+									messageId:
+										"replaceWithIntendedLiteralAndFlags",
+									pattern: regexNode.regex.pattern,
+									flags: mergedFlags,
+								});
+							}
+
+							context.report({
+								node: refNode,
+								messageId: "unexpectedRedundantRegExpWithFlags",
+								suggest: suggests.map(
+									({ flags, pattern, messageId }) => ({
+										messageId,
+										data: {
+											flags,
+										},
+										fix(fixer) {
+											return fixer.replaceText(
+												refNode,
+												getSafeOutput(
+													refNode,
+													`/${pattern}/${flags}`,
+												),
+											);
+										},
+									}),
+								),
+							});
+						} else {
+							const outputs = [];
+
+							if (
+								canFixTo(
+									refNode,
+									regexNode.regex.pattern,
+									regexNode.regex.flags,
+								)
+							) {
+								outputs.push(sourceCode.getText(regexNode));
+							}
+
+							context.report({
+								node: refNode,
+								messageId: "unexpectedRedundantRegExp",
+								suggest: outputs.map(output => ({
+									messageId: "replaceWithLiteral",
+									fix(fixer) {
+										return fixer.replaceText(
+											refNode,
+											getSafeOutput(refNode, output),
+										);
+									},
+								})),
+							});
+						}
+					} else if (hasOnlyStaticStringArguments(refNode)) {
+						let regexContent = getStringValue(refNode.arguments[0]);
+						let noFix = false;
+						let flags;
+
+						if (refNode.arguments[1]) {
+							flags = getStringValue(refNode.arguments[1]);
+						}
+
+						if (!canFixTo(refNode, regexContent, flags)) {
+							noFix = true;
+						}
+
+						if (
+							!/^[-\w\\[\](){} \t\r\n\v\f!@#$%^&*+=/~`.><?,'"|:;]*$/u.test(
+								regexContent,
+							)
+						) {
+							noFix = true;
+						}
+
+						if (regexContent && !noFix) {
+							let charIncrease = 0;
+
+							const ast = new RegExpParser({
+								ecmaVersion: regexppEcmaVersion,
+							}).parsePattern(
+								regexContent,
+								0,
+								regexContent.length,
+								{
+									unicode: flags
+										? flags.includes("u")
+										: false,
+									unicodeSets: flags
+										? flags.includes("v")
+										: false,
+								},
+							);
+
+							visitRegExpAST(ast, {
+								onCharacterEnter(characterNode) {
+									const escaped = resolveEscapes(
+										characterNode.raw,
+									);
+
+									if (escaped) {
+										regexContent =
+											regexContent.slice(
+												0,
+												characterNode.start +
+													charIncrease,
+											) +
+											escaped +
+											regexContent.slice(
+												characterNode.end +
+													charIncrease,
+											);
+
+										if (characterNode.raw.length === 1) {
+											charIncrease += 1;
+										}
+									}
+								},
+							});
+						}
+
+						const newRegExpValue = `/${regexContent || "(?:)"}/${flags || ""}`;
+
+						context.report({
+							node: refNode,
+							messageId: "unexpectedRegExp",
+							suggest: noFix
+								? []
+								: [
+										{
+											messageId: "replaceWithLiteral",
+											fix(fixer) {
+												return fixer.replaceText(
+													refNode,
+													getSafeOutput(
+														refNode,
+														newRegExpValue,
+													),
+												);
+											},
+										},
+									],
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/prefer-rest-params.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview Rule to
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Gets the variable object of `arguments` which is defined implicitly.
+ * @param {eslint-scope.Scope} scope A scope to get.
+ * @returns {eslint-scope.Variable} The found variable object.
+ */
+function getVariableOfArguments(scope) {
+	const variables = scope.variables;
+
+	for (let i = 0; i < variables.length; ++i) {
+		const variable = variables[i];
+
+		if (variable.name === "arguments") {
+			/*
+			 * If there was a parameter which is named "arguments", the implicit "arguments" is not defined.
+			 * So does fast return with null.
+			 */
+			return variable.identifiers.length === 0 ? variable : null;
+		}
+	}
+
+	/* c8 ignore next */
+	return null;
+}
+
+/**
+ * Checks if the given reference is not normal member access.
+ *
+ * - arguments         .... true    // not member access
+ * - arguments[i]      .... true    // computed member access
+ * - arguments[0]      .... true    // computed member access
+ * - arguments.length  .... false   // normal member access
+ * @param {eslint-scope.Reference} reference The reference to check.
+ * @returns {boolean} `true` if the reference is not normal member access.
+ */
+function isNotNormalMemberAccess(reference) {
+	const id = reference.identifier;
+	const parent = id.parent;
+
+	return !(
+		parent.type === "MemberExpression" &&
+		parent.object === id &&
+		!parent.computed
+	);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Require rest parameters instead of `arguments`",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/prefer-rest-params",
+		},
+
+		schema: [],
+
+		messages: {
+			preferRestParams: "Use the rest parameters instead of 'arguments'.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Reports a given reference.
+		 * @param {eslint-scope.Reference} reference A reference to report.
+		 * @returns {void}
+		 */
+		function report(reference) {
+			context.report({
+				node: reference.identifier,
+				loc: reference.identifier.loc,
+				messageId: "preferRestParams",
+			});
+		}
+
+		/**
+		 * Reports references of the implicit `arguments` variable if exist.
+		 * @param {ASTNode} node The node representing the function.
+		 * @returns {void}
+		 */
+		function checkForArguments(node) {
+			const argumentsVar = getVariableOfArguments(
+				sourceCode.getScope(node),
+			);
+
+			if (argumentsVar) {
+				argumentsVar.references
+					.filter(isNotNormalMemberAccess)
+					.forEach(report);
+			}
+		}
+
+		return {
+			"FunctionDeclaration:exit": checkForArguments,
+			"FunctionExpression:exit": checkForArguments,
+		};
+	},
+};