Add more v flag tests (#627)

* Add more `v` flag tests

* Some more tests

* Even more

* Create thin-insects-cover.md

Author: RunDevelopment

Diff for: .changeset/thin-insects-cover.md

@@ -0,0 +1,5 @@
+---
+"eslint-plugin-regexp": patch
+---
+
+Add more `v` flag tests

Diff for: tests/lib/rules/no-useless-assertions.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/no-useless-assertions"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -67,6 +67,15 @@ tester.run("no-useless-assertions", rule as any, {
                 },
             ],
         },
+        {
+            code: String.raw`/a\b[\q{foo}]/v`,
+            errors: [
+                {
+                    message:
+                        "'\\b' will always reject because it is preceded by a word character and followed by a word character.",
+                },
+            ],
+        },
         {
             code: String.raw`/,\b,/`,
             errors: [

Diff for: tests/lib/rules/no-useless-backreference.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/no-useless-backreference"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -31,6 +31,10 @@ tester.run("no-useless-backreference", rule as any, {
             code: "/(\\b)a\\1/",
             errors: [{ messageId: "empty" }],
         },
+        {
+            code: "/([\\q{}])a\\1/v",
+            errors: [{ messageId: "empty" }],
+        },
         {
             code: "/(\\b|a{0})a\\1/",
             errors: [{ messageId: "empty" }],

Diff for: tests/lib/rules/no-useless-flag.ts

@@ -6,7 +6,7 @@ import { rules } from "../../../lib/utils/rules"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -218,6 +218,8 @@ tester.run("no-useless-flag", rule as any, {
         const orig = /\w/i; // eslint-disable-line
         const clone = new RegExp(orig);
         `,
+        String.raw`/a/u`,
+        String.raw`/a/v`,
     ],
     invalid: [
         // i

Diff for: tests/lib/rules/no-useless-lazy.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/no-useless-lazy"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -34,6 +34,11 @@ tester.run("no-useless-lazy", rule as any, {
                 },
             ],
         },
+        {
+            code: `/a{1}?/v`,
+            output: `/a{1}/v`,
+            errors: [{ messageId: "constant" }],
+        },
         {
             code: `/a{4}?/`,
             output: `/a{4}/`,
@@ -72,6 +77,11 @@ tester.run("no-useless-lazy", rule as any, {
             output: `/a+b+/`,
             errors: [{ messageId: "possessive" }],
         },
+        {
+            code: String.raw`/[\q{aa|ab}]+?b+/v`,
+            output: String.raw`/[\q{aa|ab}]+b+/v`,
+            errors: [{ messageId: "possessive" }],
+        },
         {
             code: `/a*?b+/`,
             output: `/a*b+/`,

Diff for: tests/lib/rules/no-useless-non-capturing-group.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/no-useless-non-capturing-group"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -91,6 +91,19 @@ tester.run("no-useless-non-capturing-group", rule as any, {
                 },
             ],
         },
+        {
+            code: `/(?:abcd)/v.test(str)`,
+            output: `/abcd/v.test(str)`,
+            errors: [
+                {
+                    message: "Unexpected quantifier Non-capturing group.",
+                    line: 1,
+                    column: 2,
+                    endLine: 1,
+                    endColumn: 5,
+                },
+            ],
+        },
         {
             code: `/(?:[abcd])/.test(str)`,
             output: `/[abcd]/.test(str)`,

Diff for: tests/lib/rules/no-useless-quantifier.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/no-useless-quantifier"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -45,6 +45,21 @@ tester.run("no-useless-quantifier", rule as any, {
                 },
             ],
         },
+        {
+            code: String.raw`/(?:[\q{}])+/v`,
+            output: null,
+            errors: [
+                {
+                    messageId: "empty",
+                    suggestions: [
+                        {
+                            messageId: "remove",
+                            output: String.raw`/(?:[\q{}])/v`,
+                        },
+                    ],
+                },
+            ],
+        },
         {
             code: String.raw`/(?:|(?:)){5,9}/`,
             output: null,

Diff for: tests/lib/rules/no-useless-range.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/no-useless-range"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -23,6 +23,13 @@ tester.run("no-useless-range", rule as any, {
                 },
             ],
         },
+        {
+            code: `/[a-a]/v`,
+            output: `/[a]/v`,
+            errors: [
+                "Unexpected unnecessary character ranges. The hyphen is unnecessary.",
+            ],
+        },
         {
             code: `/[a-b]/`,
             output: `/[ab]/`,
@@ -35,6 +42,13 @@ tester.run("no-useless-range", rule as any, {
                 },
             ],
         },
+        {
+            code: `/[a-b]/v`,
+            output: `/[ab]/v`,
+            errors: [
+                "Unexpected unnecessary character ranges. The hyphen is unnecessary.",
+            ],
+        },
         {
             code: `/[a-a-c-c]/`,
             output: `/[a\\-c]/`,

Diff for: tests/lib/rules/no-useless-two-nums-quantifier.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/no-useless-two-nums-quantifier"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -42,5 +42,10 @@ tester.run("no-useless-two-nums-quantifier", rule as any, {
             output: "/a{100}?/",
             errors: ["Unexpected quantifier '{100,100}'."],
         },
+        {
+            code: "/a{100,100}?/v",
+            output: "/a{100}?/v",
+            errors: 1,
+        },
     ],
 })

Diff for: tests/lib/rules/no-zero-quantifier.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/no-zero-quantifier"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -22,6 +22,15 @@ tester.run("no-zero-quantifier", rule as any, {
                 },
             ],
         },
+        {
+            code: `/a{0}/v`,
+            errors: [
+                {
+                    messageId: "unexpected",
+                    suggestions: [{ output: `/(?:)/v` }],
+                },
+            ],
+        },
         {
             code: `/a{0,0}/`,
             errors: [

Diff for: tests/lib/rules/optimal-lookaround-quantifier.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/optimal-lookaround-quantifier"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -22,6 +22,17 @@ tester.run("optimal-lookaround-quantifier", rule as any, {
                 },
             ],
         },
+        {
+            code: `/(?=ba*)/v`,
+            errors: [
+                {
+                    message:
+                        "The quantified expression 'a*' at the end of the expression tree should only be matched a constant number of times. The expression can be removed without affecting the lookaround.",
+                    column: 6,
+                    suggestions: [{ output: `/(?=b)/v` }],
+                },
+            ],
+        },
         {
             code: `/(?=(?:a|b|abc*))/`,
             errors: [

Diff for: tests/lib/rules/prefer-escape-replacement-dollar-char.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/prefer-escape-replacement-dollar-char"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -34,6 +34,10 @@ tester.run("prefer-escape-replacement-dollar-char", rule as any, {
                 },
             ],
         },
+        {
+            code: `'€1,234'.replace(/€/v, '$'); // "$1,234"`,
+            errors: 1,
+        },
         {
             code: `'€1,234'.replaceAll(/€/, '$'); // "$1,234"`,
             errors: [

Diff for: tests/lib/rules/prefer-lookaround.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/prefer-lookaround"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -544,6 +544,13 @@ tester.run("prefer-lookaround", rule as any, {
                 },
             ],
         },
+        {
+            code: String.raw`var str = 'Java'.replace(/(?:^|\b|[\q{}])(J)ava/gv, '$1Query')`,
+            output: String.raw`var str = 'Java'.replace(/(?<=(?:^|\b|[\q{}])J)ava/gv, 'Query')`,
+            errors: [
+                "This capturing group can be replaced with a lookbehind assertion ('(?<=(?:^|\\b|[\\q{}])J)').",
+            ],
+        },
         {
             code: `var str = 'JavaScriptCode'.replace(/(?<=Java)(Script)Code/g, '$1Linter')`,
             output: `var str = 'JavaScriptCode'.replace(/(?<=JavaScript)Code/g, 'Linter')`,

Diff for: tests/lib/rules/prefer-named-backreference.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/prefer-named-backreference"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -16,5 +16,10 @@ tester.run("prefer-named-backreference", rule as any, {
             output: `/(?<foo>a)\\k<foo>/`,
             errors: [{ messageId: "unexpected" }],
         },
+        {
+            code: `/(?<foo>a)\\1/v`,
+            output: `/(?<foo>a)\\k<foo>/v`,
+            errors: [{ messageId: "unexpected" }],
+        },
     ],
 })

Diff for: tests/lib/rules/prefer-named-capture-group.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/prefer-named-capture-group"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -22,5 +22,11 @@ tester.run("prefer-named-capture-group", rule as any, {
                 "Capture group '(foo)' should be converted to a named or non-capturing group.",
             ],
         },
+        {
+            code: String.raw`/(foo)/v`,
+            errors: [
+                "Capture group '(foo)' should be converted to a named or non-capturing group.",
+            ],
+        },
     ],
 })

Diff for: tests/lib/rules/prefer-named-replacement.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/prefer-named-replacement"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -34,6 +34,11 @@ tester.run("prefer-named-replacement", rule as any, {
                 },
             ],
         },
+        {
+            code: `"str".replace(/a(?<foo>b)c/v, "_$1_")`,
+            output: `"str".replace(/a(?<foo>b)c/v, "_$<foo>_")`,
+            errors: ["Unexpected indexed reference in replacement string."],
+        },
         {
             code: `"str".replaceAll(/a(?<foo>b)c/, "_$1_")`,
             output: `"str".replaceAll(/a(?<foo>b)c/, "_$<foo>_")`,

Diff for: tests/lib/rules/prefer-plus-quantifier.ts

@@ -3,7 +3,7 @@ import rule from "../../../lib/rules/prefer-plus-quantifier"
 
 const tester = new RuleTester({
     parserOptions: {
-        ecmaVersion: 2020,
+        ecmaVersion: "latest",
         sourceType: "module",
     },
 })
@@ -44,6 +44,11 @@ tester.run("prefer-plus-quantifier", rule as any, {
                 },
             ],
         },
+        {
+            code: "/(a){1,}/v",
+            output: "/(a)+/v",
+            errors: ["Unexpected quantifier '{1,}'. Use '+' instead."],
+        },
         {
             code: "/(a){1,}?/",
             output: "/(a)+?/",