Add ignorePartial option to regexp/no-lazy-ends rule (#216)

Author: ota-meshi

docs/rules/no-lazy-ends.md

@@ -33,21 +33,78 @@ greedy quantifier. E.g. `a+b{2,4}?` and `a+b{2}` behave the same.
 /* eslint regexp/no-lazy-ends: "error" */
 
 /* ✓ GOOD */
-var foo = /a+?b*/
-var foo = /a??(?:ba+?|c)*/
-var foo = /ba*?$/
+var foo = /a+?b*/.test(str)
+var foo = /a??(?:ba+?|c)*/.test(str)
+var foo = /ba*?$/.test(str)
 
 /* ✗ BAD */
-var foo = /a??/
-var foo = /a+b+?/
-var foo = /a(?:c|ab+?)?/
+var foo = /a??/.test(str)
+var foo = /a+b+?/.test(str)
+var foo = /a(?:c|ab+?)?/.test(str)
 ```
 
 </eslint-code-block>
 
 ## :wrench: Options
 
-Nothing.
+```json5
+{
+  "regexp/no-lazy-ends": [
+    "error",
+    {
+      "ignorePartial": true,
+    }
+  ]
+}
+```
+
+- `ignorePartial`:
+
+  Some regexes are used as fragments to build more complex regexes. Example:
+
+  ```js
+  const any = /[\s\S]*?/.source;
+  const pattern = RegExp(`<script(\\s${any})?>(${any})<\\/script>`, "g");
+  ```
+
+  In these fragments, seemingly ignored quantifier might not actually be ignored depending on how the fragment is used.
+
+  - `true`:
+    The rule does not check the regexp used as a fragment. This is default.
+
+    <eslint-code-block>
+
+    ```js
+    /* eslint regexp/no-lazy-ends: ["error", { ignorePartial: true }] */
+
+    /* ✓ GOOD */
+    const any = /[\s\S]*?/.source;
+    const pattern = RegExp(`<script(\\s${any})?>(${any})<\\/script>`, "g");
+
+    /* ✗ BAD */
+    const foo = /[\s\S]*?/
+    foo.exec(str)
+    ```
+
+    </eslint-code-block>
+
+  - `false`:
+    This rule checks all regular expressions, including those used as fragments.
+
+    <eslint-code-block>
+
+    ```js
+    /* eslint regexp/no-lazy-ends: ["error", { ignorePartial: false }] */
+
+    /* ✗ BAD */
+    const any = /[\s\S]*?/.source;
+    const pattern = RegExp(`<script(\\s${any})?>(${any})<\\/script>`, "g");
+
+    const foo = /[\s\S]*?/
+    foo.exec(str)
+    ```
+
+    </eslint-code-block>
 
 ## :heart: Compatibility
 

lib/rules/no-lazy-ends.ts

@@ -2,6 +2,7 @@ import type { RegExpVisitor } from "regexpp/visitor"
 import type { Alternative, Quantifier } from "regexpp/ast"
 import type { RegExpContext } from "../utils"
 import { createRule, defineRegexpVisitor } from "../utils"
+import { UsageOfPattern } from "../utils/get-usage-of-pattern"
 
 /**
  * Extract lazy end quantifiers
@@ -52,7 +53,15 @@ export default createRule("no-lazy-ends", {
             recommended: false,
             default: "warn",
         },
-        schema: [],
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    ignorePartial: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             uselessElement:
                 "The quantifier and the quantified element can be removed because the quantifier is lazy and has a minimum of 0.",
@@ -64,13 +73,24 @@ export default createRule("no-lazy-ends", {
         type: "problem",
     },
     create(context) {
+        const ignorePartial = context.options[0]?.ignorePartial ?? true
+
         /**
          * Create visitor
          */
         function createVisitor({
             node,
             getRegexpLocation,
+            getUsageOfPattern,
         }: RegExpContext): RegExpVisitor.Handlers {
+            if (ignorePartial) {
+                const usageOfPattern = getUsageOfPattern()
+                if (usageOfPattern !== UsageOfPattern.whole) {
+                    // ignore
+                    return {}
+                }
+            }
+
             return {
                 onPatternEnter(pNode) {
                     for (const lazy of extractLazyEndQuantifiers(

tests/lib/rules/no-lazy-ends.ts

@@ -10,15 +10,16 @@ const tester = new RuleTester({
 
 tester.run("no-lazy-ends", rule as any, {
     valid: [
-        `/a+?b*/`,
-        `/a??(?:ba+?|c)*/`,
-        `/ba*?$/`,
+        `/a+?b*/.test(str)`,
+        `/a??(?:ba+?|c)*/.test(str)`,
+        `/ba*?$/.test(str)`,
+        `/a??/`, // UsageOfPattern.unknown
 
-        `/a{3}?/`, // uselessly lazy but that's not for this rule to correct
+        `/a{3}?/.test(str)`, // uselessly lazy but that's not for this rule to correct
     ],
     invalid: [
         {
-            code: `/a??/`,
+            code: `/a??/.test(str)`,
             errors: [
                 {
                     message:
@@ -29,7 +30,7 @@ tester.run("no-lazy-ends", rule as any, {
             ],
         },
         {
-            code: `/a*?/`,
+            code: `/a*?/.test(str)`,
             errors: [
                 {
                     message:
@@ -40,7 +41,7 @@ tester.run("no-lazy-ends", rule as any, {
             ],
         },
         {
-            code: `/a+?/`,
+            code: `/a+?/.test(str)`,
             errors: [
                 {
                     message:
@@ -51,7 +52,7 @@ tester.run("no-lazy-ends", rule as any, {
             ],
         },
         {
-            code: `/a{3,7}?/`,
+            code: `/a{3,7}?/.test(str)`,
             errors: [
                 {
                     message:
@@ -62,7 +63,7 @@ tester.run("no-lazy-ends", rule as any, {
             ],
         },
         {
-            code: `/a{3,}?/`,
+            code: `/a{3,}?/.test(str)`,
             errors: [
                 {
                     message:
@@ -74,7 +75,7 @@ tester.run("no-lazy-ends", rule as any, {
         },
 
         {
-            code: `/(?:a|b(c+?))/`,
+            code: `/(?:a|b(c+?))/.test(str)`,
             errors: [
                 {
                     message:
@@ -85,7 +86,7 @@ tester.run("no-lazy-ends", rule as any, {
             ],
         },
         {
-            code: `/a(?:c|ab+?)?/`,
+            code: `/a(?:c|ab+?)?/.test(str)`,
             errors: [
                 {
                     message:
@@ -95,5 +96,69 @@ tester.run("no-lazy-ends", rule as any, {
                 },
             ],
         },
+        {
+            code: `
+            /* ✓ GOOD */
+            const any = /[\\s\\S]*?/.source;
+            const pattern = RegExp(\`<script(\\\\s\${any})?>(\${any})<\\/script>\`, "g");
+
+            /* ✗ BAD */
+            const foo = /[\\s\\S]*?/
+            foo.exec(str)
+            `,
+            errors: [
+                {
+                    message:
+                        "The quantifier and the quantified element can be removed because the quantifier is lazy and has a minimum of 0.",
+                    line: 7,
+                    column: 26,
+                },
+            ],
+        },
+        {
+            code: `
+            /* ✓ GOOD */
+            const any = /[\\s\\S]*?/.source;
+            const pattern = RegExp(\`<script(\\\\s\${any})?>(\${any})<\\/script>\`, "g");
+
+            /* ✗ BAD */
+            const foo = /[\\s\\S]*?/
+            foo.exec(str)
+            `,
+            options: [{ ignorePartial: true }],
+            errors: [
+                {
+                    message:
+                        "The quantifier and the quantified element can be removed because the quantifier is lazy and has a minimum of 0.",
+                    line: 7,
+                    column: 26,
+                },
+            ],
+        },
+        {
+            code: `
+            /* ✗ BAD */
+            const any = /[\\s\\S]*?/.source;
+            const pattern = RegExp(\`<script(\\\\s\${any})?>(\${any})<\\/script>\`, "g");
+
+            const foo = /[\\s\\S]*?/
+            foo.exec(str)
+            `,
+            options: [{ ignorePartial: false }],
+            errors: [
+                {
+                    message:
+                        "The quantifier and the quantified element can be removed because the quantifier is lazy and has a minimum of 0.",
+                    line: 3,
+                    column: 26,
+                },
+                {
+                    message:
+                        "The quantifier and the quantified element can be removed because the quantifier is lazy and has a minimum of 0.",
+                    line: 6,
+                    column: 26,
+                },
+            ],
+        },
     ],
 })