Add disallowNeverMatch to regexp/no-dupe-disjunctions rule (#74)

* Add `disallowNeverMatch` to `regexp/no-dupe-disjunctions` rule

* Update

* update

* update

* Add testcase and fix

* fix

Author: ota-meshi

docs/rules/no-dupe-disjunctions.md

@@ -35,7 +35,43 @@ var foo = /[ab]|[ba]/
 
 ## :wrench: Options
 
-Nothing.
+```json5
+{
+  "regexp/no-dupe-disjunctions": [
+    "error",
+    {
+        "disallowNeverMatch": false
+    }
+  ]
+}
+```
+
+- `disallowNeverMatch` ... If `true`, it reports a pattern that does not match as a result of a partial duplication of the previous pattern.
+
+### `"disallowNeverMatch": true`
+
+<eslint-code-block>
+
+```js
+/* eslint regexp/no-dupe-disjunctions: ["error", { "disallowNeverMatch": true }] */
+
+/* ✓ GOOD */
+var foo = /a|b/
+var foo = /(a|b)/
+var foo = /(?:a|b)/
+
+/* ✗ BAD */
+
+// Duplication
+var foo = /a|a/
+
+// A string that matches the pattern on the right also matches the pattern on the left, so it doesn't make sense to process the pattern on the right.
+var foo = /a|abc/
+var foo = /.|abc/
+var foo = /.|a|b|c/
+```
+
+</eslint-code-block>
 
 ## :rocket: Version
 

lib/rules/no-dupe-disjunctions.ts

@@ -7,7 +7,7 @@ import type {
     Pattern,
 } from "regexpp/ast"
 import { createRule, defineRegexpVisitor, getRegexpLocation } from "../utils"
-import { isEqualNodes } from "../utils/regexp-ast"
+import { isCoveredNode, isEqualNodes } from "../utils/regexp-ast"
 
 export default createRule("no-dupe-disjunctions", {
     meta: {
@@ -17,20 +17,37 @@ export default createRule("no-dupe-disjunctions", {
             // recommended: true,
             recommended: false,
         },
-        schema: [],
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    disallowNeverMatch: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
         messages: {
             duplicated: "The disjunctions are duplicated.",
+            neverExecute:
+                "This disjunction can never match. Its condition is covered by previous conditions in the disjunctions.",
         },
         type: "suggestion", // "problem",
     },
     create(context) {
+        const disallowNeverMatch = Boolean(
+            context.options[0]?.disallowNeverMatch,
+        )
         const sourceCode = context.getSourceCode()
 
         /**
          * Create visitor
          * @param node
          */
-        function createVisitor(node: Expression): RegExpVisitor.Handlers {
+        function createVisitor(
+            node: Expression,
+            _p: string,
+            flags: string,
+        ): RegExpVisitor.Handlers {
             /** Verify group node */
             function verify(
                 regexpNode:
@@ -39,25 +56,36 @@ export default createRule("no-dupe-disjunctions", {
                     | Pattern
                     | LookaroundAssertion,
             ) {
-                const otherAlts = []
+                const leftAlts = []
                 for (const alt of regexpNode.alternatives) {
-                    const dupeAlt = otherAlts.find((o) =>
-                        isEqualNodes(alt, o, (a, _b) => {
-                            if (a.type === "CapturingGroup") {
-                                return false
-                            }
-                            return null
-                        }),
-                    )
+                    const dupeAlt = disallowNeverMatch
+                        ? leftAlts.find((leftAlt) =>
+                              isCoveredNode(leftAlt, alt, {
+                                  flags: { left: flags, right: flags },
+                              }),
+                          )
+                        : leftAlts.find((leftAlt) =>
+                              isEqualNodes(leftAlt, alt, (a, _b) => {
+                                  if (a.type === "CapturingGroup") {
+                                      return false
+                                  }
+                                  return null
+                              }),
+                          )
                     if (dupeAlt) {
                         context.report({
                             node,
                             loc: getRegexpLocation(sourceCode, node, alt),
-                            messageId: "duplicated",
+                            messageId:
+                                disallowNeverMatch &&
+                                !isEqualNodes(dupeAlt, alt)
+                                    ? "neverExecute"
+                                    : "duplicated",
                         })
-                    } else {
-                        otherAlts.push(alt)
+                        continue
                     }
+
+                    leftAlts.push(alt)
                 }
             }
 

lib/utils/regexp-ast/common.ts

@@ -0,0 +1,2 @@
+import type { Node } from "regexpp/ast"
+export type ShortCircuit = (aNode: Node, bNode: Node) => boolean | null

lib/utils/regexp-ast/index.ts

@@ -0,0 +1,62 @@
+import type { RegExpLiteral, Pattern } from "regexpp/ast"
+import type { Rule } from "eslint"
+import type { Expression } from "estree"
+import { parseRegExpLiteral, RegExpParser, visitRegExpAST } from "regexpp"
+import { getStaticValue } from "eslint-utils"
+export { ShortCircuit } from "./common"
+export * from "./is-covered"
+export * from "./is-equals"
+
+const parser = new RegExpParser()
+/**
+ * Get Reg Exp node from given expression node
+ */
+export function getRegExpNodeFromExpression(
+    node: Expression,
+    context: Rule.RuleContext,
+): RegExpLiteral | Pattern | null {
+    if (node.type === "Literal") {
+        if ("regex" in node && node.regex) {
+            try {
+                return parser.parsePattern(
+                    node.regex.pattern,
+                    0,
+                    node.regex.pattern.length,
+                    node.regex.flags.includes("u"),
+                )
+            } catch {
+                return null
+            }
+        }
+        return null
+    }
+    const evaluated = getStaticValue(node, context.getScope())
+    if (!evaluated || !(evaluated.value instanceof RegExp)) {
+        return null
+    }
+    try {
+        return parseRegExpLiteral(evaluated.value)
+    } catch {
+        return null
+    }
+}
+
+/**
+ * Extract capturing group data
+ */
+export function extractCaptures(
+    patternNode: RegExpLiteral | Pattern,
+): { names: Set<string>; count: number } {
+    let count = 0
+    const names = new Set<string>()
+    visitRegExpAST(patternNode, {
+        onCapturingGroupEnter(cgNode) {
+            count++
+            if (cgNode.name != null) {
+                names.add(cgNode.name)
+            }
+        },
+    })
+
+    return { count, names }
+}