bahlint 28.58.6934

package/lib/rules/require-unicode-regexp.js

@@ -0,0 +1,317 @@
+/**
+ * @fileoverview Rule to enforce the use of `u` or `v` flag on regular expressions.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const {
+	CALL,
+	CONSTRUCT,
+	ReferenceTracker,
+	getStringIfConstant,
+} = require("@eslint-community/eslint-utils");
+const astUtils = require("./utils/ast-utils.js");
+const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
+
+/**
+ * Checks whether the flag configuration should be treated as a missing flag.
+ * @param {"u"|"v"|undefined} requireFlag A particular flag to require
+ * @param {string} flags The regex flags
+ * @returns {boolean} Whether the flag configuration results in a missing flag.
+ */
+function checkFlags(requireFlag, flags) {
+	let missingFlag;
+
+	if (requireFlag === "v") {
+		missingFlag = !flags.includes("v");
+	} else if (requireFlag === "u") {
+		missingFlag = !flags.includes("u");
+	} else {
+		missingFlag = !flags.includes("u") && !flags.includes("v");
+	}
+
+	return missingFlag;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [{}],
+
+		docs: {
+			description:
+				"Enforce the use of `u` or `v` flag on regular expressions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/require-unicode-regexp",
+		},
+
+		hasSuggestions: true,
+
+		messages: {
+			addUFlag: "Add the 'u' flag.",
+			addVFlag: "Add the 'v' flag.",
+			requireUFlag: "Use the 'u' flag.",
+			requireVFlag: "Use the 'v' flag.",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					requireFlag: {
+						enum: ["u", "v"],
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		const [{ requireFlag }] = context.options;
+
+		return {
+			"Literal[regex]"(node) {
+				const flags = node.regex.flags || "";
+
+				const missingFlag = checkFlags(requireFlag, flags);
+
+				if (missingFlag) {
+					context.report({
+						messageId:
+							requireFlag === "v"
+								? "requireVFlag"
+								: "requireUFlag",
+						node,
+						suggest: isValidWithUnicodeFlag(
+							context.languageOptions.ecmaVersion,
+							node.regex.pattern,
+							requireFlag,
+						)
+							? [
+									{
+										fix(fixer) {
+											const replaceFlag =
+												requireFlag ?? "u";
+											const regex =
+												sourceCode.getText(node);
+											const slashPos =
+												regex.lastIndexOf("/");
+
+											if (requireFlag) {
+												const flag =
+													requireFlag === "u"
+														? "v"
+														: "u";
+
+												if (
+													regex.includes(
+														flag,
+														slashPos,
+													)
+												) {
+													return fixer.replaceText(
+														node,
+														regex.slice(
+															0,
+															slashPos,
+														) +
+															regex
+																.slice(slashPos)
+																.replace(
+																	flag,
+																	requireFlag,
+																),
+													);
+												}
+											}
+
+											return fixer.insertTextAfter(
+												node,
+												replaceFlag,
+											);
+										},
+										messageId:
+											requireFlag === "v"
+												? "addVFlag"
+												: "addUFlag",
+									},
+								]
+							: null,
+					});
+				}
+			},
+
+			Program(node) {
+				const scope = sourceCode.getScope(node);
+				const tracker = new ReferenceTracker(scope);
+				const trackMap = {
+					RegExp: { [CALL]: true, [CONSTRUCT]: true },
+				};
+
+				for (const { node: refNode } of tracker.iterateGlobalReferences(
+					trackMap,
+				)) {
+					const [patternNode, flagsNode] = refNode.arguments;
+
+					if (patternNode && patternNode.type === "SpreadElement") {
+						continue;
+					}
+					const pattern = getStringIfConstant(patternNode, scope);
+					const flags = getStringIfConstant(flagsNode, scope);
+
+					let missingFlag = !flagsNode;
+
+					if (typeof flags === "string") {
+						missingFlag = checkFlags(requireFlag, flags);
+					}
+
+					if (missingFlag) {
+						context.report({
+							messageId:
+								requireFlag === "v"
+									? "requireVFlag"
+									: "requireUFlag",
+							node: refNode,
+							suggest:
+								typeof pattern === "string" &&
+								isValidWithUnicodeFlag(
+									context.languageOptions.ecmaVersion,
+									pattern,
+									requireFlag,
+								)
+									? [
+											{
+												fix(fixer) {
+													const replaceFlag =
+														requireFlag ?? "u";
+
+													if (flagsNode) {
+														if (
+															(flagsNode.type ===
+																"Literal" &&
+																typeof flagsNode.value ===
+																	"string") ||
+															flagsNode.type ===
+																"TemplateLiteral"
+														) {
+															const flagsNodeText =
+																sourceCode.getText(
+																	flagsNode,
+																);
+															const flag =
+																requireFlag ===
+																"u"
+																	? "v"
+																	: "u";
+
+															if (
+																flags.includes(
+																	flag,
+																)
+															) {
+																// Avoid replacing "u" in escapes like `\uXXXX`
+																if (
+																	flagsNode.type ===
+																		"Literal" &&
+																	flagsNode.raw.includes(
+																		"\\",
+																	)
+																) {
+																	return null;
+																}
+
+																// Avoid replacing "u" in expressions like "`${regularFlags}g`"
+																if (
+																	flagsNode.type ===
+																		"TemplateLiteral" &&
+																	(flagsNode
+																		.expressions
+																		.length ||
+																		flagsNode.quasis.some(
+																			({
+																				value: {
+																					raw,
+																				},
+																			}) =>
+																				raw.includes(
+																					"\\",
+																				),
+																		))
+																) {
+																	return null;
+																}
+
+																return fixer.replaceText(
+																	flagsNode,
+																	flagsNodeText.replace(
+																		flag,
+																		replaceFlag,
+																	),
+																);
+															}
+
+															return fixer.replaceText(
+																flagsNode,
+																[
+																	flagsNodeText.slice(
+																		0,
+																		flagsNodeText.length -
+																			1,
+																	),
+																	flagsNodeText.slice(
+																		flagsNodeText.length -
+																			1,
+																	),
+																].join(
+																	replaceFlag,
+																),
+															);
+														}
+
+														// We intentionally don't suggest concatenating + "u" to non-literals
+														return null;
+													}
+
+													const penultimateToken =
+														sourceCode.getLastToken(
+															refNode,
+															{ skip: 1 },
+														); // skip closing parenthesis
+
+													return fixer.insertTextAfter(
+														penultimateToken,
+														astUtils.isCommaToken(
+															penultimateToken,
+														)
+															? ` "${replaceFlag}",`
+															: `, "${replaceFlag}"`,
+													);
+												},
+												messageId:
+													requireFlag === "v"
+														? "addVFlag"
+														: "addUFlag",
+											},
+										]
+									: null,
+						});
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/require-yield.js

@@ -0,0 +1,86 @@
+/**
+ * @fileoverview Rule to flag the generator functions that does not have yield.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Require generator functions to contain `yield`",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/require-yield",
+		},
+
+		schema: [],
+
+		messages: {
+			missingYield: "This generator function does not have 'yield'.",
+		},
+	},
+
+	create(context) {
+		const stack = [];
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * If the node is a generator function, start counting `yield` keywords.
+		 * @param {Node} node A function node to check.
+		 * @returns {void}
+		 */
+		function beginChecking(node) {
+			if (node.generator) {
+				stack.push(0);
+			}
+		}
+
+		/**
+		 * If the node is a generator function, end counting `yield` keywords, then
+		 * reports result.
+		 * @param {Node} node A function node to check.
+		 * @returns {void}
+		 */
+		function endChecking(node) {
+			if (!node.generator) {
+				return;
+			}
+
+			const countYield = stack.pop();
+
+			if (countYield === 0 && node.body.body.length > 0) {
+				context.report({
+					loc: astUtils.getFunctionHeadLoc(node, sourceCode),
+					messageId: "missingYield",
+				});
+			}
+		}
+
+		return {
+			FunctionDeclaration: beginChecking,
+			"FunctionDeclaration:exit": endChecking,
+			FunctionExpression: beginChecking,
+			"FunctionExpression:exit": endChecking,
+
+			// Increases the count of `yield` keyword.
+			YieldExpression() {
+				if (stack.length > 0) {
+					stack[stack.length - 1] += 1;
+				}
+			},
+		};
+	},
+};

package/lib/rules/rest-spread-spacing.js

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Enforce spacing between rest and spread operators and their expressions.
+ * @author Kai Cataldo
+ * @deprecated in ESLint v8.53.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		deprecated: {
+			message: "Formatting rules are being moved out of ESLint core.",
+			url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
+			deprecatedSince: "8.53.0",
+			availableUntil: "11.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "rest-spread-spacing",
+						url: "https://eslint.style/rules/rest-spread-spacing",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description:
+				"Enforce spacing between rest and spread operators and their expressions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/rest-spread-spacing",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				enum: ["always", "never"],
+			},
+		],
+
+		messages: {
+			unexpectedWhitespace:
+				"Unexpected whitespace after {{type}} operator.",
+			expectedWhitespace: "Expected whitespace after {{type}} operator.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode,
+			alwaysSpace = context.options[0] === "always";
+
+		//--------------------------------------------------------------------------
+		// Helpers
+		//--------------------------------------------------------------------------
+
+		/**
+		 * Checks whitespace between rest/spread operators and their expressions
+		 * @param {ASTNode} node The node to check
+		 * @returns {void}
+		 */
+		function checkWhiteSpace(node) {
+			const operator = sourceCode.getFirstToken(node),
+				nextToken = sourceCode.getTokenAfter(operator),
+				hasWhitespace = sourceCode.isSpaceBetween(operator, nextToken);
+			let type;
+
+			switch (node.type) {
+				case "SpreadElement":
+					type = "spread";
+					if (node.parent.type === "ObjectExpression") {
+						type += " property";
+					}
+					break;
+				case "RestElement":
+					type = "rest";
+					if (node.parent.type === "ObjectPattern") {
+						type += " property";
+					}
+					break;
+				case "ExperimentalSpreadProperty":
+					type = "spread property";
+					break;
+				case "ExperimentalRestProperty":
+					type = "rest property";
+					break;
+				default:
+					return;
+			}
+
+			if (alwaysSpace && !hasWhitespace) {
+				context.report({
+					node,
+					loc: operator.loc,
+					messageId: "expectedWhitespace",
+					data: {
+						type,
+					},
+					fix(fixer) {
+						return fixer.replaceTextRange(
+							[operator.range[1], nextToken.range[0]],
+							" ",
+						);
+					},
+				});
+			} else if (!alwaysSpace && hasWhitespace) {
+				context.report({
+					node,
+					loc: {
+						start: operator.loc.end,
+						end: nextToken.loc.start,
+					},
+					messageId: "unexpectedWhitespace",
+					data: {
+						type,
+					},
+					fix(fixer) {
+						return fixer.removeRange([
+							operator.range[1],
+							nextToken.range[0],
+						]);
+					},
+				});
+			}
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			SpreadElement: checkWhiteSpace,
+			RestElement: checkWhiteSpace,
+			ExperimentalSpreadProperty: checkWhiteSpace,
+			ExperimentalRestProperty: checkWhiteSpace,
+		};
+	},
+};