eslint 8.57.1 → 9.39.1

package/lib/rules/prefer-named-capture-group.js

@@ -10,13 +10,19 @@
 //------------------------------------------------------------------------------
 
 const {
-    CALL,
-    CONSTRUCT,
-    ReferenceTracker,
-    getStringIfConstant
+	CALL,
+	CONSTRUCT,
+	ReferenceTracker,
+	getStringIfConstant,
 } = require("@eslint-community/eslint-utils");
 const regexpp = require("@eslint-community/regexpp");
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @import { SuggestedEdit } from "@eslint/core"; */
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -29,150 +35,163 @@ const parser = new regexpp.RegExpParser();
  * @param {string} pattern The regular expression pattern to be checked.
  * @param {string} rawText Source text of the regexNode.
  * @param {ASTNode} regexNode AST node which contains the regular expression.
- * @returns {Array<SuggestionResult>} Fixer suggestions for the regex, if statically determinable.
+ * @returns {Array<SuggestedEdit>} Fixer suggestions for the regex, if statically determinable.
  */
 function suggestIfPossible(groupStart, pattern, rawText, regexNode) {
-    switch (regexNode.type) {
-        case "Literal":
-            if (typeof regexNode.value === "string" && rawText.includes("\\")) {
-                return null;
-            }
-            break;
-        case "TemplateLiteral":
-            if (regexNode.expressions.length || rawText.slice(1, -1) !== pattern) {
-                return null;
-            }
-            break;
-        default:
-            return null;
-    }
-
-    const start = regexNode.range[0] + groupStart + 2;
-
-    return [
-        {
-            fix(fixer) {
-                const existingTemps = pattern.match(/temp\d+/gu) || [];
-                const highestTempCount = existingTemps.reduce(
-                    (previous, next) =>
-                        Math.max(previous, Number(next.slice("temp".length))),
-                    0
-                );
-
-                return fixer.insertTextBeforeRange(
-                    [start, start],
-                    `?<temp${highestTempCount + 1}>`
-                );
-            },
-            messageId: "addGroupName"
-        },
-        {
-            fix(fixer) {
-                return fixer.insertTextBeforeRange(
-                    [start, start],
-                    "?:"
-                );
-            },
-            messageId: "addNonCapture"
-        }
-    ];
+	switch (regexNode.type) {
+		case "Literal":
+			if (typeof regexNode.value === "string" && rawText.includes("\\")) {
+				return null;
+			}
+			break;
+		case "TemplateLiteral":
+			if (
+				regexNode.expressions.length ||
+				rawText.slice(1, -1) !== pattern
+			) {
+				return null;
+			}
+			break;
+		default:
+			return null;
+	}
+
+	const start = regexNode.range[0] + groupStart + 2;
+
+	return [
+		{
+			fix(fixer) {
+				const existingTemps = pattern.match(/temp\d+/gu) || [];
+				const highestTempCount = existingTemps.reduce(
+					(previous, next) =>
+						Math.max(previous, Number(next.slice("temp".length))),
+					0,
+				);
+
+				return fixer.insertTextBeforeRange(
+					[start, start],
+					`?<temp${highestTempCount + 1}>`,
+				);
+			},
+			messageId: "addGroupName",
+		},
+		{
+			fix(fixer) {
+				return fixer.insertTextBeforeRange([start, start], "?:");
+			},
+			messageId: "addNonCapture",
+		},
+	];
 }
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Enforce using named capture group in regular expression",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-named-capture-group"
-        },
-
-        hasSuggestions: true,
-
-        schema: [],
-
-        messages: {
-            addGroupName: "Add name to capture group.",
-            addNonCapture: "Convert group to non-capturing.",
-            required: "Capture group '{{group}}' should be converted to a named or non-capturing group."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Function to check regular expression.
-         * @param {string} pattern The regular expression pattern to be checked.
-         * @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
-         * @param {ASTNode} regexNode AST node which contains the regular expression.
-         * @param {string|null} flags The regular expression flags to be checked.
-         * @returns {void}
-         */
-        function checkRegex(pattern, node, regexNode, flags) {
-            let ast;
-
-            try {
-                ast = parser.parsePattern(pattern, 0, pattern.length, {
-                    unicode: Boolean(flags && flags.includes("u")),
-                    unicodeSets: Boolean(flags && flags.includes("v"))
-                });
-            } catch {
-
-                // ignore regex syntax errors
-                return;
-            }
-
-            regexpp.visitRegExpAST(ast, {
-                onCapturingGroupEnter(group) {
-                    if (!group.name) {
-                        const rawText = sourceCode.getText(regexNode);
-                        const suggest = suggestIfPossible(group.start, pattern, rawText, regexNode);
-
-                        context.report({
-                            node,
-                            messageId: "required",
-                            data: {
-                                group: group.raw
-                            },
-                            suggest
-                        });
-                    }
-                }
-            });
-        }
-
-        return {
-            Literal(node) {
-                if (node.regex) {
-                    checkRegex(node.regex.pattern, node, node, node.regex.flags);
-                }
-            },
-            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)) {
-                    const regex = getStringIfConstant(refNode.arguments[0]);
-                    const flags = getStringIfConstant(refNode.arguments[1]);
-
-                    if (regex) {
-                        checkRegex(regex, refNode, refNode.arguments[0], flags);
-                    }
-                }
-            }
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Enforce using named capture group in regular expression",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/prefer-named-capture-group",
+		},
+
+		hasSuggestions: true,
+
+		schema: [],
+
+		messages: {
+			addGroupName: "Add name to capture group.",
+			addNonCapture: "Convert group to non-capturing.",
+			required:
+				"Capture group '{{group}}' should be converted to a named or non-capturing group.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		/**
+		 * Function to check regular expression.
+		 * @param {string} pattern The regular expression pattern to be checked.
+		 * @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
+		 * @param {ASTNode} regexNode AST node which contains the regular expression.
+		 * @param {string|null} flags The regular expression flags to be checked.
+		 * @returns {void}
+		 */
+		function checkRegex(pattern, node, regexNode, flags) {
+			let ast;
+
+			try {
+				ast = parser.parsePattern(pattern, 0, pattern.length, {
+					unicode: Boolean(flags && flags.includes("u")),
+					unicodeSets: Boolean(flags && flags.includes("v")),
+				});
+			} catch {
+				// ignore regex syntax errors
+				return;
+			}
+
+			regexpp.visitRegExpAST(ast, {
+				onCapturingGroupEnter(group) {
+					if (!group.name) {
+						const rawText = sourceCode.getText(regexNode);
+						const suggest = suggestIfPossible(
+							group.start,
+							pattern,
+							rawText,
+							regexNode,
+						);
+
+						context.report({
+							node,
+							messageId: "required",
+							data: {
+								group: group.raw,
+							},
+							suggest,
+						});
+					}
+				},
+			});
+		}
+
+		return {
+			Literal(node) {
+				if (node.regex) {
+					checkRegex(
+						node.regex.pattern,
+						node,
+						node,
+						node.regex.flags,
+					);
+				}
+			},
+			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,
+				)) {
+					const regex = getStringIfConstant(refNode.arguments[0]);
+					const flags = getStringIfConstant(refNode.arguments[1]);
+
+					if (regex) {
+						checkRegex(regex, refNode, refNode.arguments[0], flags);
+					}
+				}
+			},
+		};
+	},
 };

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

@@ -16,9 +16,9 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 const radixMap = new Map([
-    [2, { system: "binary", literalPrefix: "0b" }],
-    [8, { system: "octal", literalPrefix: "0o" }],
-    [16, { system: "hexadecimal", literalPrefix: "0x" }]
+	[2, { system: "binary", literalPrefix: "0b" }],
+	[8, { system: "octal", literalPrefix: "0o" }],
+	[16, { system: "hexadecimal", literalPrefix: "0x" }],
 ]);
 
 /**
@@ -29,120 +29,129 @@ const radixMap = new Map([
  * false otherwise.
  */
 function isParseInt(calleeNode) {
-    return (
-        astUtils.isSpecificId(calleeNode, "parseInt") ||
-        astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")
-    );
+	return (
+		astUtils.isSpecificId(calleeNode, "parseInt") ||
+		astUtils.isSpecificMemberAccess(calleeNode, "Number", "parseInt")
+	);
 }
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/prefer-numeric-literals"
-        },
-
-        schema: [],
-
-        messages: {
-            useLiteral: "Use {{system}} literals instead of {{functionName}}()."
-        },
-
-        fixable: "code"
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        //----------------------------------------------------------------------
-        // Public
-        //----------------------------------------------------------------------
-
-        return {
-
-            "CallExpression[arguments.length=2]"(node) {
-                const [strNode, radixNode] = node.arguments,
-                    str = astUtils.getStaticStringValue(strNode),
-                    radix = radixNode.value;
-
-                if (
-                    str !== null &&
-                    astUtils.isStringLiteral(strNode) &&
-                    radixNode.type === "Literal" &&
-                    typeof radix === "number" &&
-                    radixMap.has(radix) &&
-                    isParseInt(node.callee)
-                ) {
-
-                    const { system, literalPrefix } = radixMap.get(radix);
-
-                    context.report({
-                        node,
-                        messageId: "useLiteral",
-                        data: {
-                            system,
-                            functionName: sourceCode.getText(node.callee)
-                        },
-                        fix(fixer) {
-                            if (sourceCode.getCommentsInside(node).length) {
-                                return null;
-                            }
-
-                            const replacement = `${literalPrefix}${str}`;
-
-                            if (+replacement !== parseInt(str, radix)) {
-
-                                /*
-                                 * If the newly-produced literal would be invalid, (e.g. 0b1234),
-                                 * or it would yield an incorrect parseInt result for some other reason, don't make a fix.
-                                 *
-                                 * If `str` had numeric separators, `+replacement` will evaluate to `NaN` because unary `+`
-                                 * per the specification doesn't support numeric separators. Thus, the above condition will be `true`
-                                 * (`NaN !== anything` is always `true`) regardless of the `parseInt(str, radix)` value.
-                                 * Consequently, no autofixes will be made. This is correct behavior because `parseInt` also
-                                 * doesn't support numeric separators, but it does parse part of the string before the first `_`,
-                                 * so the autofix would be invalid:
-                                 *
-                                 *   parseInt("1_1", 2) // === 1
-                                 *   0b1_1 // === 3
-                                 */
-                                return null;
-                            }
-
-                            const tokenBefore = sourceCode.getTokenBefore(node),
-                                tokenAfter = sourceCode.getTokenAfter(node);
-                            let prefix = "",
-                                suffix = "";
-
-                            if (
-                                tokenBefore &&
-                                tokenBefore.range[1] === node.range[0] &&
-                                !astUtils.canTokensBeAdjacent(tokenBefore, replacement)
-                            ) {
-                                prefix = " ";
-                            }
-
-                            if (
-                                tokenAfter &&
-                                node.range[1] === tokenAfter.range[0] &&
-                                !astUtils.canTokensBeAdjacent(replacement, tokenAfter)
-                            ) {
-                                suffix = " ";
-                            }
-
-                            return fixer.replaceText(node, `${prefix}${replacement}${suffix}`);
-                        }
-                    });
-                }
-            }
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/prefer-numeric-literals",
+		},
+
+		schema: [],
+
+		messages: {
+			useLiteral:
+				"Use {{system}} literals instead of {{functionName}}().",
+		},
+
+		fixable: "code",
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		//----------------------------------------------------------------------
+		// Public
+		//----------------------------------------------------------------------
+
+		return {
+			"CallExpression[arguments.length=2]"(node) {
+				const [strNode, radixNode] = node.arguments,
+					str = astUtils.getStaticStringValue(strNode),
+					radix = radixNode.value;
+
+				if (
+					str !== null &&
+					astUtils.isStringLiteral(strNode) &&
+					radixNode.type === "Literal" &&
+					typeof radix === "number" &&
+					radixMap.has(radix) &&
+					isParseInt(node.callee)
+				) {
+					const { system, literalPrefix } = radixMap.get(radix);
+
+					context.report({
+						node,
+						messageId: "useLiteral",
+						data: {
+							system,
+							functionName: sourceCode.getText(node.callee),
+						},
+						fix(fixer) {
+							if (sourceCode.getCommentsInside(node).length) {
+								return null;
+							}
+
+							const replacement = `${literalPrefix}${str}`;
+
+							if (+replacement !== parseInt(str, radix)) {
+								/*
+								 * If the newly-produced literal would be invalid, (e.g. 0b1234),
+								 * or it would yield an incorrect parseInt result for some other reason, don't make a fix.
+								 *
+								 * If `str` had numeric separators, `+replacement` will evaluate to `NaN` because unary `+`
+								 * per the specification doesn't support numeric separators. Thus, the above condition will be `true`
+								 * (`NaN !== anything` is always `true`) regardless of the `parseInt(str, radix)` value.
+								 * Consequently, no autofixes will be made. This is correct behavior because `parseInt` also
+								 * doesn't support numeric separators, but it does parse part of the string before the first `_`,
+								 * so the autofix would be invalid:
+								 *
+								 *   parseInt("1_1", 2) // === 1
+								 *   0b1_1 // === 3
+								 */
+								return null;
+							}
+
+							const tokenBefore = sourceCode.getTokenBefore(node),
+								tokenAfter = sourceCode.getTokenAfter(node);
+							let prefix = "",
+								suffix = "";
+
+							if (
+								tokenBefore &&
+								tokenBefore.range[1] === node.range[0] &&
+								!astUtils.canTokensBeAdjacent(
+									tokenBefore,
+									replacement,
+								)
+							) {
+								prefix = " ";
+							}
+
+							if (
+								tokenAfter &&
+								node.range[1] === tokenAfter.range[0] &&
+								!astUtils.canTokensBeAdjacent(
+									replacement,
+									tokenAfter,
+								)
+							) {
+								suffix = " ";
+							}
+
+							return fixer.replaceText(
+								node,
+								`${prefix}${replacement}${suffix}`,
+							);
+						},
+					});
+				}
+			},
+		};
+	},
 };