feat: add requireFlag option to require-unicode-regexp rule (#18836)

* feat: requireFlag option * docs: add option docs * docs: precise JSON schema Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: remove extra example Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: format directive Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: remove extra example Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: format directive Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: remove extra example Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: format directive Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: remove extra example Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: format directive Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * fix: remove extra quotes Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * test: cover trailing comma * fix: only provide suggestion if flags node is string literal without escapes or template literal with no expressions and no escapes * avoid flag checks when flag-to-replace not present * check `flags` and append where flag safely not found * simplify fixer Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * docs: rationale for choosing the flags * Update docs/src/rules/require-unicode-regexp.md Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> * Update docs/src/rules/require-unicode-regexp.md Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com> --------- Co-authored-by: Milos Djermanovic <milos.djermanovic@gmail.com>

Author: brettz9

docs/src/rules/require-unicode-regexp.md

@@ -98,6 +98,87 @@ function i(flags) {
 
 :::
 
+## Options
+
+This rule has one object option:
+
+* `"requireFlag": "u"|"v"` requires a particular Unicode regex flag
+
+### requireFlag: "u"
+
+The `u` flag may be preferred in environments that do not support the `v` flag.
+
+Examples of **incorrect** code for this rule with the `{ "requireFlag": "u" }` option:
+
+:::incorrect
+
+```js
+/*eslint require-unicode-regexp: ["error", { "requireFlag": "u" }] */
+
+const fooEmpty = /foo/;
+
+const fooEmptyRegexp = new RegExp('foo');
+
+const foo = /foo/v;
+
+const fooRegexp = new RegExp('foo', 'v');
+```
+
+:::
+
+Examples of **correct** code for this rule with the `{ "requireFlag": "u" }` option:
+
+:::correct
+
+```js
+/*eslint require-unicode-regexp: ["error", { "requireFlag": "u" }] */
+
+const foo = /foo/u;
+
+const fooRegexp = new RegExp('foo', 'u');
+```
+
+:::
+
+### requireFlag: "v"
+
+The `v` flag may be a better choice when it is supported because it has more
+features than the `u` flag (e.g., the ability to test Unicode properties of strings). It
+does have a stricter syntax, however (e.g., the need to escape certain
+characters within character classes).
+
+Examples of **incorrect** code for this rule with the `{ "requireFlag": "v" }` option:
+
+:::incorrect
+
+```js
+/*eslint require-unicode-regexp: ["error", { "requireFlag": "v" }] */
+
+const fooEmpty = /foo/;
+
+const fooEmptyRegexp = new RegExp('foo');
+
+const foo = /foo/u;
+
+const fooRegexp = new RegExp('foo', 'u');
+```
+
+:::
+
+Examples of **correct** code for this rule with the `{ "requireFlag": "v" }` option:
+
+:::correct
+
+```js
+/*eslint require-unicode-regexp: ["error", { "requireFlag": "v" }] */
+
+const foo = /foo/v;
+
+const fooRegexp = new RegExp('foo', 'v');
+```
+
+:::
+
 ## When Not To Use It
 
 If you don't want to warn on regular expressions without either a `u` or a `v` flag, then it's safe to disable this rule.

lib/rules/require-unicode-regexp.js

@@ -18,6 +18,26 @@ const {
 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
 //------------------------------------------------------------------------------
@@ -37,31 +57,65 @@ module.exports = {
 
  messages: {
  addUFlag: "Add the 'u' flag.",
- requireUFlag: "Use the 'u' flag."
+ addVFlag: "Add the 'v' flag.",
+ requireUFlag: "Use the 'u' flag.",
+ requireVFlag: "Use the 'v' flag."
  },
 
- schema: []
+ schema: [
+ {
+ type: "object",
+ properties: {
+ requireFlag: {
+ enum: ["u", "v"]
+ }
+ },
+ additionalProperties: false
+ }
+ ]
  },
 
  create(context) {
 
  const sourceCode = context.sourceCode;
 
+ const {
+ requireFlag
+ } = context.options[0] ?? {};
+
  return {
  "Literal[regex]"(node) {
  const flags = node.regex.flags || "";
 
- if (!flags.includes("u") && !flags.includes("v")) {
+ const missingFlag = checkFlags(requireFlag, flags);
+
+ if (missingFlag) {
  context.report({
- messageId: "requireUFlag",
+ messageId: requireFlag === "v" ? "requireVFlag" : "requireUFlag",
  node,
- suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern)
+ suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern, requireFlag)
  ? [
  {
  fix(fixer) {
- return fixer.insertTextAfter(node, "u");
+ 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: "addUFlag"
+ messageId: requireFlag === "v" ? "addVFlag" : "addUFlag"
  }
  ]
  : null
@@ -85,22 +139,49 @@ module.exports = {
  const pattern = getStringIfConstant(patternNode, scope);
  const flags = getStringIfConstant(flagsNode, scope);
 
- if (!flagsNode || (typeof flags === "string" && !flags.includes("u") && !flags.includes("v"))) {
+ let missingFlag = !flagsNode;
+
+ if (typeof flags === "string") {
+ missingFlag = checkFlags(requireFlag, flags);
+ }
+
+ if (missingFlag) {
  context.report({
- messageId: "requireUFlag",
+ messageId: requireFlag === "v" ? "requireVFlag" : "requireUFlag",
  node: refNode,
- suggest: typeof pattern === "string" && isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)
+ 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("u"));
+ ].join(replaceFlag));
  }
 
  // We intentionally don't suggest concatenating + "u" to non-literals
@@ -112,11 +193,11 @@ module.exports = {
  return fixer.insertTextAfter(
  penultimateToken,
  astUtils.isCommaToken(penultimateToken)
- ? ' "u",'
- : ', "u"'
+ ? ` "${replaceFlag}",`
+ : `, "${replaceFlag}"`
  );
  },
- messageId: "addUFlag"
+ messageId: requireFlag === "v" ? "addVFlag" : "addUFlag"
  }
  ]
  : null

lib/rules/utils/regular-expressions.js

@@ -14,12 +14,16 @@ const REGEXPP_LATEST_ECMA_VERSION = 2025;
  * Checks if the given regular expression pattern would be valid with the `u` flag.
  * @param {number} ecmaVersion ECMAScript version to parse in.
  * @param {string} pattern The regular expression pattern to verify.
+ * @param {"u"|"v"} flag The type of Unicode flag
  * @returns {boolean} `true` if the pattern would be valid with the `u` flag.
  * `false` if the pattern would be invalid with the `u` flag or the configured
  * ecmaVersion doesn't support the `u` flag.
  */
-function isValidWithUnicodeFlag(ecmaVersion, pattern) {
- if (ecmaVersion <= 5) { // ecmaVersion <= 5 doesn't support the 'u' flag
+function isValidWithUnicodeFlag(ecmaVersion, pattern, flag = "u") {
+ if (flag === "u" && ecmaVersion <= 5) { // ecmaVersion <= 5 doesn't support the 'u' flag
+ return false;
+ }
+ if (flag === "v" && ecmaVersion <= 2023) {
  return false;
  }
 
@@ -28,7 +32,11 @@ function isValidWithUnicodeFlag(ecmaVersion, pattern) {
  });
 
  try {
- validator.validatePattern(pattern, void 0, void 0, { unicode: /* uFlag = */ true });
+ validator.validatePattern(pattern, void 0, void 0, flag === "u" ? {
+ unicode: /* uFlag = */ true
+ } : {
+ unicodeSets: true
+ });
  } catch {
  return false;
  }