Fix false positives for backreference and invalid escape in regexp/no-useless-character-class rule (#42)

Author: ota-meshi

lib/rules/no-useless-character-class.ts

@@ -1,6 +1,7 @@
 import type { Expression } from "estree"
 import type { RegExpVisitor } from "regexpp/visitor"
 import {
+    canUnwrapped,
     createRule,
     defineRegexpVisitor,
     fixerApplyEscape,
@@ -85,6 +86,9 @@ export default createRule("no-useless-character-class", {
                         ) {
                             return
                         }
+                        if (!canUnwrapped(ccNode, element.raw)) {
+                            return
+                        }
                     } else if (element.type === "CharacterClassRange") {
                         if (element.min.value !== element.max.value) {
                             return

lib/utils/index.ts

@@ -1,7 +1,17 @@
 import type * as ESTree from "estree"
 import type { RuleListener, RuleModule, PartialRuleModule } from "../types"
 import type { RegExpVisitor } from "regexpp/visitor"
-import type { Node as RegExpNode, Quantifier } from "regexpp/ast"
+import type {
+    Alternative,
+    AnyCharacterSet,
+    Assertion,
+    Backreference,
+    CapturingGroup,
+    CharacterClass,
+    Group,
+    Node as RegExpNode,
+    Quantifier,
+} from "regexpp/ast"
 import { RegExpParser, visitRegExpAST } from "regexpp"
 import {
     CALL,
@@ -345,3 +355,112 @@ export function getQuantifierOffsets(qNode: Quantifier): [number, number] {
     const endOffset = qNode.raw.length - (qNode.greedy ? 0 : 1)
     return [startOffset, endOffset]
 }
+
+/* eslint-disable complexity -- X( */
+/**
+ * Check the siblings to see if the regex doesn't change when unwrapped.
+ */
+export function canUnwrapped(
+    /* eslint-enable complexity -- X( */
+    node:
+        | CharacterClass
+        | Group
+        | CapturingGroup
+        | Assertion
+        | Quantifier
+        | AnyCharacterSet
+        | Backreference,
+    text: string,
+): boolean {
+    const { alternative, index } = getAlternativeAndIndex()
+    if (index === 0) {
+        return true
+    }
+    if (/^\d+$/u.test(text)) {
+        let prevIndex = index - 1
+        let prev = alternative.elements[prevIndex]
+        if (prev.type === "Backreference") {
+            // e.g. /()\1[0]/ -> /()\10/
+            return false
+        }
+
+        while (
+            prev.type === "Character" &&
+            /^\d+$/u.test(prev.raw) &&
+            prevIndex > 0
+        ) {
+            prevIndex--
+            prev = alternative.elements[prevIndex]
+        }
+        if (prev.type === "Character" && prev.raw === "{") {
+            // e.g. /a{[0]}/ -> /a{0}/
+            return false
+        }
+    }
+    if (/^[0-7]+$/u.test(text)) {
+        const prev = alternative.elements[index - 1]
+        if (prev.type === "Character" && /^\\[0-7]+$/u.test(prev.raw)) {
+            // e.g. /\0[1]/ -> /\01/
+            return false
+        }
+    }
+    if (/^[\da-f]+$/iu.test(text)) {
+        let prevIndex = index - 1
+        let prev = alternative.elements[prevIndex]
+        while (
+            prev.type === "Character" &&
+            /^[\da-f]+$/iu.test(prev.raw) &&
+            prevIndex > 0
+        ) {
+            prevIndex--
+            prev = alternative.elements[prevIndex]
+        }
+        if (
+            prev.type === "Character" &&
+            (prev.raw === "\\x" || prev.raw === "\\u")
+        ) {
+            // e.g. /\xF[F]/ -> /\xFF/
+            // e.g. /\uF[F]FF/ -> /\xFFFF/
+            return false
+        }
+    }
+    if (/^[a-z]+$/iu.test(text)) {
+        if (index > 1) {
+            const prev = alternative.elements[index - 1]
+            if (prev.type === "Character" && prev.raw === "c") {
+                const prev2 = alternative.elements[index - 2]
+                if (prev2.type === "Character" && prev2.raw === "\\") {
+                    // e.g. /\c[M]/ -> /\cM/
+                    return false
+                }
+            }
+        }
+    }
+
+    return true
+
+    /** Get alternative and element index */
+    function getAlternativeAndIndex() {
+        const parent = node.parent
+        let target:
+                | CharacterClass
+                | Group
+                | CapturingGroup
+                | Assertion
+                | Quantifier
+                | AnyCharacterSet
+                | Backreference,
+            alt: Alternative
+        if (parent.type === "Quantifier") {
+            alt = parent.parent
+            target = parent
+        } else {
+            alt = parent
+            target = node
+        }
+        return {
+            alternative: alt,
+            index: alt.elements.indexOf(target),
+        }
+    }
+}

tests/lib/rules/no-useless-character-class.ts

@@ -33,6 +33,20 @@ tester.run("no-useless-character-class", rule as any, {
         String.raw`/(,)(,)(,)(,)(,) (,)(,)(,)(,)(,) (,)[\7]/ // back reference escape`,
         String.raw`/(,)(,)(,)(,)(,) (,)(,)(,)(,)(,) (,)[\11]/ // back reference escape`,
         String.raw`/\0/`,
+        String.raw`/\1[0]/`,
+        String.raw`/\0[1]/`,
+        String.raw`/a{[0]}/`,
+        String.raw`/a{123[0]}/`,
+        `/\\xF[F]/`,
+        `/\\xf[f]/`,
+        `/\\x4[4]/`,
+        `/\\uF[F]FF/`,
+        `/\\uf[f]ff/`,
+        `/\\u4[4]44/`,
+        String.raw`/\c[M]/`,
+        String.raw`/\c[A]/`,
+        String.raw`/\c[Z]/`,
+        String.raw`/\c[m]/`,
     ],
     invalid: [
         {