Fix false positives for disallowNeverMatch option in regexp/no-dupe-disjunctions rule (#80)

Author: ota-meshi

lib/rules/no-dupe-disjunctions.ts

@@ -5,6 +5,7 @@ import type {
     Group,
     LookaroundAssertion,
     Pattern,
+    Quantifier,
 } from "regexpp/ast"
 import { createRule, defineRegexpVisitor, getRegexpLocation } from "../utils"
 import { isCoveredNode, isEqualNodes } from "../utils/regexp-ast"
@@ -39,6 +40,35 @@ export default createRule("no-dupe-disjunctions", {
         )
         const sourceCode = context.getSourceCode()
 
+        /**
+         * Check has after pattern
+         */
+        function hasAfterPattern(
+            node: Group | CapturingGroup | Pattern | LookaroundAssertion,
+        ): boolean {
+            if (node.type === "Assertion") {
+                return false
+            }
+            if (node.type === "Pattern") {
+                return false
+            }
+            let target: Group | CapturingGroup | Quantifier = node
+            let parent = target.parent
+            while (parent) {
+                if (parent.type === "Alternative") {
+                    const index = parent.elements.indexOf(target)
+                    return index < parent.elements.length - 1
+                }
+                if (parent.type === "Quantifier") {
+                    target = parent
+                    parent = target.parent
+                    continue
+                }
+                return false
+            }
+            return false
+        }
+
         /**
          * Create visitor
          * @param node
@@ -56,12 +86,15 @@ export default createRule("no-dupe-disjunctions", {
                     | Pattern
                     | LookaroundAssertion,
             ) {
+                const canOmitRight =
+                    disallowNeverMatch && !hasAfterPattern(regexpNode)
                 const leftAlts = []
                 for (const alt of regexpNode.alternatives) {
                     const dupeAlt = disallowNeverMatch
                         ? leftAlts.find((leftAlt) =>
                               isCoveredNode(leftAlt, alt, {
                                   flags: { left: flags, right: flags },
+                                  canOmitRight,
                               }),
                           )
                         : leftAlts.find((leftAlt) =>

lib/utils/regexp-ast/is-covered.ts

@@ -32,6 +32,7 @@ type Options = {
         left: string
         right: string
     }
+    canOmitRight: boolean
 }
 interface NormalizedNodeBase {
     readonly type: string
@@ -777,6 +778,9 @@ function isCoveredAltNodes(
     right: NormalizedNode[],
     options: Options,
 ) {
+    // if (options.canOmitRight) {
+    //     return isCoveredAltNodesForCanOmitRight(left, right, options)
+    // }
     let leftIndex = 0
     let rightIndex = 0
     while (leftIndex < left.length && rightIndex < right.length) {
@@ -820,6 +824,11 @@ function isCoveredAltNodes(
         leftIndex++
         rightIndex++
     }
+    if (!options.canOmitRight) {
+        if (rightIndex < right.length) {
+            return false
+        }
+    }
     while (leftIndex < left.length) {
         const le = left[leftIndex]
         if (le.type !== "NormalizedOptional") {
@@ -829,3 +838,62 @@ function isCoveredAltNodes(
     }
     return leftIndex >= left.length
 }
+
+/** Check whether the right nodes is covered by the left nodes. */
+// function isCoveredAltNodesForCanOmitRight(
+//     left: NormalizedNode[],
+//     right: NormalizedNode[],
+//     options: Options,
+// ) {
+//     let leftIndex = 0
+//     let rightIndex = 0
+//     while (leftIndex < left.length && rightIndex < right.length) {
+//         const le = left[leftIndex]
+//         const re = right[rightIndex]
+
+//         if (re.type === "NormalizedOptional") {
+//             rightIndex++
+//             continue
+//         } else if (le.type === "NormalizedOptional") {
+//             // Checks if skipped.
+//             const skippedLeftItems = left.slice(leftIndex + 1)
+//             if (
+//                 isCoveredAltNodes(
+//                     skippedLeftItems,
+//                     right.slice(rightIndex),
+//                     options,
+//                 )
+//             ) {
+//                 return true
+//             }
+//             if (!isCoveredForNormalizedNode(le.element, re, options)) {
+//                 // I know it won't match if I skip it.
+//                 return false
+//             }
+//             if (le.max >= 2) {
+//                 // Check for multiple iterations.
+//                 if (
+//                     isCoveredAltNodes(
+//                         [le.decrementMax(), ...skippedLeftItems],
+//                         right.slice(rightIndex + 1),
+//                         options,
+//                     )
+//                 ) {
+//                     return true
+//                 }
+//             }
+//         } else if (!isCoveredForNormalizedNode(le, re, options)) {
+//             return false
+//         }
+//         leftIndex++
+//         rightIndex++
+//     }
+//     while (leftIndex < left.length) {
+//         const le = left[leftIndex]
+//         if (le.type !== "NormalizedOptional") {
+//             return false
+//         }
+//         leftIndex++
+//     }
+//     return leftIndex >= left.length
+// }

tests/lib/rules/no-dupe-disjunctions.ts

@@ -10,7 +10,16 @@ const tester = new RuleTester({
 
 tester.run("no-dupe-disjunctions", rule as any, {
     valid: [
-        ...[`/a|b/`, `/(a|b)/`, `/(?:a|b)/`, `/((?:ab|ba)|(?:ba|ac))/`].reduce(
+        ...[
+            `/a|b/`,
+            `/(a|b)/`,
+            `/(?:a|b)/`,
+            `/((?:ab|ba)|(?:ba|ac))/`,
+            `/(?:js|json)$/`,
+            `/(?:js|jso?n?)$/`,
+            `/(?:js|json)abc/`,
+            `/(?:js|json)?abc/`,
+        ].reduce(
             (acc, x) =>
                 acc.concat(x, {
                     code: x,

tests/lib/utils/regexp-ast.ts

@@ -511,6 +511,7 @@ describe("regexp-ast isCoveredNode", () => {
             assert.deepStrictEqual(
                 isCoveredNode(ast1, ast2, {
                     flags: { left: ast1.flags.raw, right: ast2.flags.raw },
+                    canOmitRight: true,
                 }),
                 testCase.result,
             )