Add regexp/optimal-lookaround-quantifier rule (#97)

ota-meshi · RunDevelopment · web-flow · commit feaf1219a8fe · 2021-04-14T20:19:12.000+09:00
* Add `regexp/optimal-lookaround-quantifier` rule * Refactored optimal lookahead quantifier (#101) Co-authored-by: Michael Schmidt <mitchi5000.ms@googlemail.com>
diff --git a/README.md b/README.md
@@ -108,6 +108,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-useless-non-greedy](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-non-greedy.html) | disallow unnecessary quantifier non-greedy (`?`) | :wrench: |
 | [regexp/no-useless-range](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-range.html) | disallow unnecessary range of characters by using a hyphen | :wrench: |
 | [regexp/no-useless-two-nums-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/no-useless-two-nums-quantifier.html) | disallow unnecessary `{n,m}` quantifier | :star: |
+| [regexp/optimal-lookaround-quantifier](https://ota-meshi.github.io/eslint-plugin-regexp/rules/optimal-lookaround-quantifier.html) | disallow the alternatives of lookarounds that end with a non-constant quantifier |  |
 | [regexp/order-in-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/order-in-character-class.html) | enforces elements order in character class | :wrench: |
 | [regexp/prefer-character-class](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-character-class.html) | enforce using character class | :wrench: |
 | [regexp/prefer-d](https://ota-meshi.github.io/eslint-plugin-regexp/rules/prefer-d.html) | enforce using `\d` | :star::wrench: |
diff --git a/docs/rules/README.md b/docs/rules/README.md
@@ -36,6 +36,7 @@ The rules with the following star :star: are included in the `plugin:regexp/reco
 | [regexp/no-useless-non-greedy](./no-useless-non-greedy.md) | disallow unnecessary quantifier non-greedy (`?`) | :wrench: |
 | [regexp/no-useless-range](./no-useless-range.md) | disallow unnecessary range of characters by using a hyphen | :wrench: |
 | [regexp/no-useless-two-nums-quantifier](./no-useless-two-nums-quantifier.md) | disallow unnecessary `{n,m}` quantifier | :star: |
+| [regexp/optimal-lookaround-quantifier](./optimal-lookaround-quantifier.md) | disallow the alternatives of lookarounds that end with a non-constant quantifier |  |
 | [regexp/order-in-character-class](./order-in-character-class.md) | enforces elements order in character class | :wrench: |
 | [regexp/prefer-character-class](./prefer-character-class.md) | enforce using character class | :wrench: |
 | [regexp/prefer-d](./prefer-d.md) | enforce using `\d` | :star::wrench: |
diff --git a/docs/rules/optimal-lookaround-quantifier.md b/docs/rules/optimal-lookaround-quantifier.md
@@ -0,0 +1,74 @@
+---
+pageClass: "rule-details"
+sidebarDepth: 0
+title: "regexp/optimal-lookaround-quantifier"
+description: "disallow the alternatives of lookarounds that end with a non-constant quantifier"
+---
+# regexp/optimal-lookaround-quantifier
+
+> disallow the alternatives of lookarounds that end with a non-constant quantifier
+
+- :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> ***This rule has not been released yet.*** </badge>
+
+## :book: Rule Details
+
+Non-constant quantifiers are quantifiers that describe a range (e.g. `?`, `*`,
+`+`, `{0,1}`, `{5,9}`, `{3,}`). They have to match some number of times (the
+minimum) after which further matches are optional until a certain maximum (may
+be infinite) is reached.
+
+It's obvious that `/ba{2}/` and `/ba{2,6}/` will match differently because of
+the different quantifiers of `a` but that not the case if for lookarounds. Both
+`/b(?=a{2})/` and `/b(?=a{2,6})/` will match strings the same way. I.e. for the
+input string `"baaa"`, both will create the same match arrays. The two regular
+expression are actually equivalent, meaning that `(?=a{2})` is equivalent to
+`(?=a{2,6})`.
+
+More generally, if a non-constant quantifier is an **end** of the expression
+tree of a **lookahead**, that quantifier can be replaced with a constant
+quantifier that matched the element minimum-if-the-non-constant-quantifier many
+times. For **lookbehinds**, the non-constant quantifier has to be at the
+**start** of the expression tree as lookbehinds are matched from right to left.
+
+<eslint-code-block>
+
+```js
+/* eslint regexp/optimal-lookaround-quantifier: "error" */
+
+/* ✓ GOOD */
+// lookaheads
+var foo = /\w+(?=\s*:)/;
+
+// lookbehinds
+var foo = /(?<=ab+)/;
+
+/* ✗ BAD */
+// lookaheads
+var foo = /(?=ab+)/; // == /(?=ab)/
+var foo = /(?=ab*)/; // == /(?=a)/
+var foo = /(?!ab?)/; // == /(?!a)/
+var foo = /(?!ab{6,})/; // == /(?!ab{6})/
+
+// lookbehinds
+var foo = /(?<=a+b)/; // == /(?<=ab)/
+var foo = /(?<!\w*\s*,)/; // == /(?<!,)/
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :heart: Compatibility
+
+This rule was taken from [eslint-plugin-clean-regex].  
+This rule is compatible with [clean-regex/optimal-lookaround-quantifier] rule.
+
+[eslint-plugin-clean-regex]: https://github.com/RunDevelopment/eslint-plugin-clean-regex
+[clean-regex/optimal-lookaround-quantifier]: https://github.com/RunDevelopment/eslint-plugin-clean-regex/blob/master/docs/rules/optimal-lookaround-quantifier.md
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/lib/rules/optimal-lookaround-quantifier.ts)
+- [Test source](https://github.com/ota-meshi/eslint-plugin-regexp/blob/master/tests/lib/rules/optimal-lookaround-quantifier.ts)
diff --git a/lib/rules/optimal-lookaround-quantifier.ts b/lib/rules/optimal-lookaround-quantifier.ts
@@ -0,0 +1,112 @@
+import type { Expression } from "estree"
+import type { RegExpVisitor } from "regexpp/visitor"
+import type { Alternative, LookaroundAssertion, Quantifier } from "regexpp/ast"
+import { createRule, defineRegexpVisitor, getRegexpLocation } from "../utils"
+
+/**
+ * Extract invalid quantifiers for lookarounds
+ */
+function* extractInvalidQuantifiers(
+    alternatives: Alternative[],
+    kind: LookaroundAssertion["kind"],
+): IterableIterator<Quantifier> {
+    for (const { elements } of alternatives) {
+        if (elements.length > 0) {
+            const lastIndex = kind === "lookahead" ? elements.length - 1 : 0
+            const last = elements[lastIndex]
+            switch (last.type) {
+                case "Quantifier":
+                    if (last.min !== last.max) {
+                        // TODO: last might contain a capturing group in which cause, we can't change the quantifier
+                        yield last
+                    }
+                    break
+
+                case "Group":
+                    yield* extractInvalidQuantifiers(last.alternatives, kind)
+                    break
+
+                // we ignore capturing groups on purpose.
+                // Example: /(?=(a*))\w+\1/ (no ideal but it illustrates the point)
+
+                default:
+                    break
+            }
+        }
+    }
+}
+
+const END_START_PHRASE = {
+    lookahead: "end",
+    lookbehind: "start",
+}
+
+export default createRule("optimal-lookaround-quantifier", {
+    meta: {
+        docs: {
+            description:
+                "disallow the alternatives of lookarounds that end with a non-constant quantifier",
+            // TODO Switch to recommended in the major version.
+            // recommended: true,
+            recommended: false,
+            default: "warn",
+        },
+        schema: [],
+        messages: {
+            remove:
+                "The quantified expression {{expr}} at the {{endOrStart}} of the expression tree should only be matched a constant number of times. The expression can be removed without affecting the lookaround.",
+            replacedWith:
+                "The quantified expression {{expr}} at the {{endOrStart}} of the expression tree should only be matched a constant number of times. The expression can be replaced with {{replacer}} without affecting the lookaround.",
+        },
+        type: "problem",
+    },
+    create(context) {
+        const sourceCode = context.getSourceCode()
+
+        /**
+         * Create visitor
+         * @param node
+         */
+        function createVisitor(node: Expression): RegExpVisitor.Handlers {
+            return {
+                onAssertionEnter(aNode) {
+                    if (
+                        aNode.kind === "lookahead" ||
+                        aNode.kind === "lookbehind"
+                    ) {
+                        const endOrStart = END_START_PHRASE[aNode.kind]
+                        const quantifiers = extractInvalidQuantifiers(
+                            aNode.alternatives,
+                            aNode.kind,
+                        )
+
+                        for (const q of quantifiers) {
+                            const replacer =
+                                q.min === 0
+                                    ? ""
+                                    : q.min === 1
+                                    ? `${q.element.raw} (no quantifier)`
+                                    : `${q.element.raw}{${q.min}}`
+
+                            context.report({
+                                node,
+                                loc: getRegexpLocation(sourceCode, node, q),
+                                messageId:
+                                    q.min === 0 ? "remove" : "replacedWith",
+                                data: {
+                                    expr: q.raw,
+                                    endOrStart,
+                                    replacer,
+                                },
+                            })
+                        }
+                    }
+                },
+            }
+        }
+
+        return defineRegexpVisitor(context, {
+            createVisitor,
+        })
+    },
+})
diff --git a/lib/utils/rules.ts b/lib/utils/rules.ts
@@ -24,6 +24,7 @@ import noUselessNonCapturingGroup from "../rules/no-useless-non-capturing-group"
 import noUselessNonGreedy from "../rules/no-useless-non-greedy"
 import noUselessRange from "../rules/no-useless-range"
 import noUselessTwoNumsQuantifier from "../rules/no-useless-two-nums-quantifier"
+import optimalLookaroundQuantifier from "../rules/optimal-lookaround-quantifier"
 import orderInCharacterClass from "../rules/order-in-character-class"
 import preferCharacterClass from "../rules/prefer-character-class"
 import preferD from "../rules/prefer-d"
@@ -65,6 +66,7 @@ export const rules = [
     noUselessNonGreedy,
     noUselessRange,
     noUselessTwoNumsQuantifier,
+    optimalLookaroundQuantifier,
     orderInCharacterClass,
     preferCharacterClass,
     preferD,
diff --git a/tests/lib/rules/optimal-lookaround-quantifier.ts b/tests/lib/rules/optimal-lookaround-quantifier.ts
@@ -0,0 +1,81 @@
+import { RuleTester } from "eslint"
+import rule from "../../../lib/rules/optimal-lookaround-quantifier"
+
+const tester = new RuleTester({
+    parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: "module",
+    },
+})
+
+tester.run("optimal-lookaround-quantifier", rule as any, {
+    valid: [String.raw`/(?=(a*))\w+\1/`, `/(?<=a{4})/`],
+    invalid: [
+        {
+            code: `/(?=ba*)/`,
+            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.",
+                    line: 1,
+                    column: 6,
+                },
+            ],
+        },
+        {
+            code: `/(?=(?:a|b|abc*))/`,
+            errors: [
+                {
+                    message:
+                        "The quantified expression c* 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.",
+                    line: 1,
+                    column: 14,
+                },
+            ],
+        },
+        {
+            code: `/(?=(?:a|b|abc+))/`,
+            errors: [
+                {
+                    message:
+                        "The quantified expression c+ at the end of the expression tree should only be matched a constant number of times. The expression can be replaced with c (no quantifier) without affecting the lookaround.",
+                    line: 1,
+                    column: 14,
+                },
+            ],
+        },
+        {
+            code: `/(?=(?:a|b|abc{4,9}))/`,
+            errors: [
+                {
+                    message:
+                        "The quantified expression c{4,9} at the end of the expression tree should only be matched a constant number of times. The expression can be replaced with c{4} without affecting the lookaround.",
+                    line: 1,
+                    column: 14,
+                },
+            ],
+        },
+        {
+            code: `/(?<=[a-c]*)/`,
+            errors: [
+                {
+                    message:
+                        "The quantified expression [a-c]* at the start of the expression tree should only be matched a constant number of times. The expression can be removed without affecting the lookaround.",
+                    line: 1,
+                    column: 6,
+                },
+            ],
+        },
+        {
+            code: `/(?<=(c)*ab)/`,
+            errors: [
+                {
+                    message:
+                        "The quantified expression (c)* at the start of the expression tree should only be matched a constant number of times. The expression can be removed without affecting the lookaround.",
+                    line: 1,
+                    column: 6,
+                },
+            ],
+        },
+    ],
+})
