Fix false positives for matchAll in regexp/no-unused-capturing-group rule (#403)

ota-meshi · web-flow · commit 9a780beaa03b · 2022-03-11T17:21:08.000+01:00
diff --git a/lib/rules/no-unused-capturing-group.ts b/lib/rules/no-unused-capturing-group.ts
@@ -114,7 +114,7 @@ export default createRule("no-unused-capturing-group", {
                     ref.type === "ReplacerFunctionRef"
                 ) {
                     if (ref.kind === "index") {
-                        if (ref.ref) {
+                        if (ref.ref != null) {
                             indexRefs.push(ref.ref)
                         } else {
                             return null
diff --git a/lib/utils/extract-capturing-group-references.ts b/lib/utils/extract-capturing-group-references.ts
@@ -136,6 +136,56 @@ type ExtractCapturingGroupReferencesContext = {
     isString: (node: Expression) => boolean
 }
 
+type ArrayMethodName = Exclude<keyof unknown[], "length" | symbol | number>
+const WELL_KNOWN_ARRAY_METHODS: {
+    [key in ArrayMethodName]: {
+        // If specified, the method receives a function that iterates the element.
+        // Specify an array with the index of the argument that receives the element.
+        elementParameters?: number[]
+        result?:
+            | "element" // The method returns the element.
+            | "array" // The method returns an array with some of the elements.]
+            | "iterator" // The method returns an iterator with some of the elements.
+    }
+} = {
+    toString: {},
+    toLocaleString: {},
+    pop: { result: "element" },
+    push: {},
+    concat: { result: "array" },
+    join: {},
+    reverse: { result: "array" },
+    shift: { result: "element" },
+    slice: { result: "array" },
+    sort: { elementParameters: [0, 1], result: "array" },
+    splice: { result: "array" },
+    unshift: {},
+    indexOf: {},
+    lastIndexOf: {},
+    every: { elementParameters: [0] },
+    some: { elementParameters: [0] },
+    forEach: { elementParameters: [0] },
+    map: { elementParameters: [0] },
+    filter: { elementParameters: [0], result: "array" },
+    reduce: { elementParameters: [1] },
+    reduceRight: { elementParameters: [1] },
+    // ES2015
+    find: { elementParameters: [0], result: "element" },
+    findIndex: { elementParameters: [0] },
+    fill: {},
+    copyWithin: { result: "array" },
+    entries: {},
+    keys: {},
+    values: { result: "iterator" },
+    // ES2016
+    includes: {},
+    // ES2019
+    flatMap: { elementParameters: [0] },
+    flat: {},
+    // ES2022
+    at: { result: "element" },
+}
+
 /**
  * Extracts the usage of the capturing group.
  */
@@ -234,11 +284,9 @@ function* iterateForMember(
     object: Expression,
     ctx: ExtractCapturingGroupReferencesContext,
 ): Iterable<CapturingGroupReference> {
-    const parent = getParent(memberExpression)
+    const parent = getCallExpressionFromCalleeExpression(memberExpression)
     if (
         !parent ||
-        parent.type !== "CallExpression" ||
-        parent.callee !== memberExpression ||
         !isKnownMethodCall(parent, {
             test: 1,
             exec: 1,
@@ -335,7 +383,7 @@ function* iterateForStringReplace(
 
 /** Iterate the capturing group references for String.prototype.matchAll(). */
 function* iterateForStringMatchAll(
-    node: KnownMethodCall,
+    node: CallExpression,
     argument: Expression,
     ctx: ExtractCapturingGroupReferencesContext,
 ): Iterable<CapturingGroupReference> {
@@ -351,37 +399,41 @@ function* iterateForStringMatchAll(
             return
         }
         if (hasNameRef(iterationRef)) {
+            if (
+                iterationRef.type === "member" &&
+                isWellKnownArrayMethodName(iterationRef.name)
+            ) {
+                const call = getCallExpressionFromCalleeExpression(
+                    iterationRef.node,
+                )
+                if (call) {
+                    for (const cgRef of iterateForArrayMethodOfStringMatchAll(
+                        call,
+                        iterationRef.name,
+                        argument,
+                        ctx,
+                    )) {
+                        useRet = true
+                        yield cgRef
+                        if (cgRef.type === "UnknownRef") {
+                            return
+                        }
+                    }
+                }
+                continue
+            }
             if (Number.isNaN(Number(iterationRef.name))) {
                 // Not aimed to iteration.
                 continue
             }
         }
         for (const ref of iterationRef.extractPropertyReferences()) {
-            if (hasNameRef(ref)) {
-                if (ref.name === "groups") {
-                    for (const namedRef of ref.extractPropertyReferences()) {
-                        useRet = true
-                        yield getNamedArrayRef(namedRef)
-                    }
-                } else {
-                    if (
-                        ref.name === "input" ||
-                        ref.name === "index" ||
-                        ref.name === "indices"
-                    ) {
-                        continue
-                    }
-                    useRet = true
-                    yield getIndexArrayRef(ref)
-                }
-            } else {
+            for (const cgRef of iterateForRegExpMatchArrayReference(ref)) {
                 useRet = true
-                yield {
-                    type: "UnknownRef",
-                    kind: "array",
-                    prop: ref,
+                yield cgRef
+                if (cgRef.type === "UnknownRef") {
+                    return
                 }
-                return
             }
         }
     }
@@ -420,28 +472,11 @@ function* iterateForExecResult(
     ctx: ExtractCapturingGroupReferencesContext,
 ): Iterable<CapturingGroupReference> {
     for (const ref of extractPropertyReferences(node, ctx.context)) {
-        if (hasNameRef(ref)) {
-            if (ref.name === "groups") {
-                for (const namedRef of ref.extractPropertyReferences()) {
-                    yield getNamedArrayRef(namedRef)
-                }
-            } else {
-                if (
-                    ref.name === "input" ||
-                    ref.name === "index" ||
-                    ref.name === "indices"
-                ) {
-                    continue
-                }
-                yield getIndexArrayRef(ref)
-            }
-        } else {
-            yield {
-                type: "UnknownRef",
-                kind: "array",
-                prop: ref,
+        for (const cgRef of iterateForRegExpMatchArrayReference(ref)) {
+            yield cgRef
+            if (cgRef.type === "UnknownRef") {
+                return
             }
-            return
         }
     }
 }
@@ -590,6 +625,75 @@ function* iterateForReplacerFunction(
     }
 }
 
+/** Iterate the capturing group references for RegExpMatchArray reference. */
+function* iterateForRegExpMatchArrayReference(
+    ref: PropertyReference,
+): Iterable<CapturingGroupReference> {
+    if (hasNameRef(ref)) {
+        if (ref.name === "groups") {
+            for (const namedRef of ref.extractPropertyReferences()) {
+                yield getNamedArrayRef(namedRef)
+            }
+        } else {
+            if (
+                ref.name === "input" ||
+                ref.name === "index" ||
+                ref.name === "indices"
+            ) {
+                return
+            }
+            yield getIndexArrayRef(ref)
+        }
+    } else {
+        yield {
+            type: "UnknownRef",
+            kind: "array",
+            prop: ref,
+        }
+    }
+}
+
+/** Iterate the capturing group references for Array method of String.prototype.matchAll(). */
+function* iterateForArrayMethodOfStringMatchAll(
+    node: CallExpression,
+    methodsName: ArrayMethodName,
+    argument: Expression,
+    ctx: ExtractCapturingGroupReferencesContext,
+): Iterable<CapturingGroupReference> {
+    const arrayMethod = WELL_KNOWN_ARRAY_METHODS[methodsName]
+    if (
+        arrayMethod.elementParameters &&
+        node.arguments[0] &&
+        (node.arguments[0].type === "FunctionExpression" ||
+            node.arguments[0].type === "ArrowFunctionExpression")
+    ) {
+        const fnNode = node.arguments[0]
+        for (const index of arrayMethod.elementParameters) {
+            const param = fnNode.params[index]
+            if (param) {
+                for (const ref of extractPropertyReferencesForPattern(
+                    param,
+                    ctx.context,
+                )) {
+                    yield* iterateForRegExpMatchArrayReference(ref)
+                }
+            }
+        }
+    }
+    if (arrayMethod.result) {
+        if (arrayMethod.result === "element") {
+            for (const ref of extractPropertyReferences(node, ctx.context)) {
+                yield* iterateForRegExpMatchArrayReference(ref)
+            }
+        } else if (
+            arrayMethod.result === "array" ||
+            arrayMethod.result === "iterator"
+        ) {
+            yield* iterateForStringMatchAll(node, argument, ctx)
+        }
+    }
+}
+
 /** Checks whether the given reference is a named reference. */
 function hasNameRef(
     ref: PropertyReference,
@@ -638,3 +742,23 @@ function getNamedArrayRef(
         prop: namedRef,
     }
 }
+
+/** Gets the CallExpression from the given callee node. */
+function getCallExpressionFromCalleeExpression(
+    expression: Expression,
+): CallExpression | null {
+    const parent = getParent(expression)
+    if (
+        !parent ||
+        parent.type !== "CallExpression" ||
+        parent.callee !== expression
+    ) {
+        return null
+    }
+    return parent
+}
+
+/** Checks whether the given name is a well known array method name. */
+function isWellKnownArrayMethodName(name: string): name is ArrayMethodName {
+    return Boolean(WELL_KNOWN_ARRAY_METHODS[name as ArrayMethodName])
+}
diff --git a/tests/lib/rules/no-unused-capturing-group.ts b/tests/lib/rules/no-unused-capturing-group.ts
@@ -134,6 +134,20 @@ tester.run("no-unused-capturing-group", rule as any, {
         String.raw`
         const matches = [...('2000-12-31 2000-12-31'.matchAll(/(\d{4})-(\d{2})-(\d{2})/g))]
         `,
+        String.raw`
+        const bs = [...'abc_abc'.matchAll(/a(b)/g)].map(m => m[1])
+        `,
+        String.raw`
+        ;[...'abc_abc'.matchAll(/a(b)(c)/g)].forEach(m => console.log(m[1], m[2]))
+        `,
+        String.raw`
+        const filtered = [...'abc_abc_abb_acc'.matchAll(/(?<a>.)(?<b>.)(?<c>.)/g)].filter(m => m.groups.b === m.groups.c);
+        console.log(filtered[0].groups.a);
+        `,
+        String.raw`
+        const element = [...'abc_abc_abb_acc'.matchAll(/(?<a>.)(?<b>.)(?<c>.)/g)].find(m => m.groups.b === m.groups.c);
+        console.log(element.groups.a);
+        `,
     ],
     invalid: [
         {
@@ -469,5 +483,52 @@ tester.run("no-unused-capturing-group", rule as any, {
             code: `'str'.replace(/(?<foo>\\w+)/, () => {});`,
             errors: ["Capturing group 'foo' is defined but never used."],
         },
+        {
+            code: String.raw`
+            const bs = [...'abc_abc'.matchAll(/a(b)/g)].map(m => m[0])
+            `,
+            output: String.raw`
+            const bs = [...'abc_abc'.matchAll(/a(?:b)/g)].map(m => m[0])
+            `,
+            options: [{ fixable: true }],
+            errors: ["Capturing group number 1 is defined but never used."],
+        },
+        {
+            code: String.raw`
+            ;[...'abc_abc'.matchAll(/a(b)(c)/g)].forEach(m => console.log(m[1]))
+            `,
+            output: String.raw`
+            ;[...'abc_abc'.matchAll(/a(b)(?:c)/g)].forEach(m => console.log(m[1]))
+            `,
+            options: [{ fixable: true }],
+            errors: ["Capturing group number 2 is defined but never used."],
+        },
+        {
+            code: String.raw`
+            const filtered = [...'abc_abc_abb_acc'.matchAll(/(?<a>.)(?<b>.)(?<c>.)/g)].filter(m => m.groups.b === m.groups.c);
+            console.log(filtered[0].groups.b);
+            `,
+            output: null,
+            options: [{ fixable: true }],
+            errors: ["Capturing group 'a' is defined but never used."],
+        },
+        {
+            code: String.raw`
+            const filtered = [...'abc_abc_abb_acc'.matchAll(/(?<a>.)(?<b>.)(?<c>.)/g)].filter(m => m.groups.a === m.groups.c);
+            console.log(filtered[0].groups.a);
+            `,
+            output: null,
+            options: [{ fixable: true }],
+            errors: ["Capturing group 'b' is defined but never used."],
+        },
+        {
+            code: String.raw`
+            const element = [...'abc_abc_abb_acc'.matchAll(/(?<a>.)(?<b>.)(?<c>.)/g)].find(m => m.groups.a === m.groups.c);
+            console.log(element.groups.a);
+            `,
+            output: null,
+            options: [{ fixable: true }],
+            errors: ["Capturing group 'b' is defined but never used."],
+        },
     ],
 })
