Fix false negatives in prefer-result-array-groups rule (#356)

* Fix false negatives in `prefer-result-array-groups` rule

* Add test

Author: ota-meshi

lib/rules/prefer-result-array-groups.ts

@@ -6,7 +6,10 @@ import {
     getTypeScriptTools,
     isAny,
     isClassOrInterface,
+    isUnionOrIntersection,
+    isNull,
 } from "../utils/ts-utils"
+import type * as TS from "typescript"
 import type { Expression, Super } from "estree"
 
 export default createRule("prefer-result-array-groups", {
@@ -149,16 +152,33 @@ export default createRule("prefer-result-array-groups", {
                 return "unknown"
             }
 
-            if (isClassOrInterface(tsType)) {
-                const name = tsType.symbol.escapedName
-                return name === "RegExpMatchArray" || name === "RegExpExecArray"
-                    ? "RegExpXArray"
-                    : "unknown"
-            }
             if (isAny(tsType)) {
                 return "any"
             }
+            if (isRegExpMatchArrayOrRegExpExecArray(tsType)) {
+                return "RegExpXArray"
+            }
+            if (isUnionOrIntersection(tsType)) {
+                if (
+                    tsType.types.every(
+                        (t) =>
+                            isRegExpMatchArrayOrRegExpExecArray(t) || isNull(t),
+                    )
+                ) {
+                    // e.g. (RegExpExecArray | null)
+                    return "RegExpXArray"
+                }
+            }
             return "unknown"
         }
+
+        /** Checks whether given type is RegExpMatchArray or RegExpExecArray or not */
+        function isRegExpMatchArrayOrRegExpExecArray(tsType: TS.Type) {
+            if (isClassOrInterface(tsType)) {
+                const name = tsType.symbol.escapedName
+                return name === "RegExpMatchArray" || name === "RegExpExecArray"
+            }
+            return false
+        }
     },
 })

lib/utils/ast-utils/extract-expression-references.ts

@@ -4,14 +4,18 @@ import type {
     ArrayPattern,
     ArrowFunctionExpression,
     CallExpression,
+    ConditionalExpression,
     Expression,
     ForOfStatement,
     FunctionDeclaration,
     FunctionExpression,
     Identifier,
+    IfStatement,
+    LogicalExpression,
     MemberExpression,
     ObjectPattern,
     Pattern,
+    UnaryExpression,
 } from "estree"
 import { findFunction, findVariable, getParent } from "./utils"
 
@@ -100,7 +104,13 @@ function* iterateReferencesForExpression(
 ): Iterable<ExpressionReference> {
     let node = expression
     let parent = getParent(node)
-    while (parent?.type === "ChainExpression") {
+    while (
+        parent?.type === "ChainExpression" ||
+        // @ts-expect-error -- TS AST
+        parent?.type === "TSNonNullExpression" ||
+        // @ts-expect-error -- TS AST
+        parent?.type === "TSAsExpression"
+    ) {
         node = parent
         parent = getParent(node)
     }
@@ -172,11 +182,46 @@ function* iterateReferencesForExpression(
         } else {
             yield { node, type: "unknown" }
         }
+    } else if (
+        parent.type === "IfStatement" ||
+        parent.type === "ConditionalExpression" ||
+        parent.type === "LogicalExpression" ||
+        parent.type === "UnaryExpression"
+    ) {
+        if (isUsedInTest(parent, node)) {
+            // The expression used in the test does not need to be tracked and returns nothing.
+        } else {
+            yield { node, type: "unknown" }
+        }
     } else {
         yield { node, type: "unknown" }
     }
 }
 
+/** Checks whether the expression is used in the test. */
+function isUsedInTest(
+    parent:
+        | IfStatement
+        | ConditionalExpression
+        | LogicalExpression
+        | UnaryExpression,
+    node: Expression,
+) {
+    if (parent.type === "IfStatement") {
+        return parent.test === node
+    }
+    if (parent.type === "ConditionalExpression") {
+        return parent.test === node
+    }
+    if (parent.type === "LogicalExpression") {
+        return parent.operator === "&&" && parent.left === node
+    }
+    if (parent.type === "UnaryExpression") {
+        return parent.operator === "!" && parent.argument === node
+    }
+    return false
+}
+
 /** Iterate references for the given pattern node. */
 function* iterateReferencesForESPattern(
     expression: Expression,

lib/utils/ts-utils/index.ts

@@ -155,3 +155,10 @@ export function isBigIntLike(tsType: TS.Type): boolean {
     const ts = getTypeScript()!
     return (tsType.flags & ts.TypeFlags.BigIntLike) !== 0
 }
+/**
+ * Check if a given type is an null type or not.
+ */
+export function isNull(tsType: TS.Type): boolean {
+    const ts = getTypeScript()!
+    return (tsType.flags & ts.TypeFlags.Null) !== 0
+}

tests/lib/rules/prefer-result-array-groups.ts

@@ -409,5 +409,89 @@ tester.run("prefer-result-array-groups", rule as any, {
                 "Unexpected indexed access for the named capturing group 'foo' from regexp result array.",
             ],
         },
+        {
+            // https://github.com/ota-meshi/eslint-plugin-regexp/issues/355
+            filename: path.join(__dirname, "prefer-result-array-groups.ts"),
+            code: `
+            const match = /(?<foo>foo)/u.exec(str)!
+            match[1]; // <-
+
+            /(?<bar>bar)/u.exec(str)?.[1]; // <-
+            const match2 = /(?<baz>baz)/u.exec(str)
+            match2?.[1] // <-
+
+            const match3 = /(?<qux>qux)/u.exec(str) as RegExpExecArray
+            match3[1] // <-
+            `,
+            output: `
+            const match = /(?<foo>foo)/u.exec(str)!
+            match.groups!.foo; // <-
+
+            /(?<bar>bar)/u.exec(str)?.groups!.bar; // <-
+            const match2 = /(?<baz>baz)/u.exec(str)
+            match2?.groups!.baz // <-
+
+            const match3 = /(?<qux>qux)/u.exec(str) as RegExpExecArray
+            match3.groups!.qux // <-
+            `,
+            parser: require.resolve("@typescript-eslint/parser"),
+            parserOptions: {
+                project: require.resolve("../../../tsconfig.json"),
+            },
+            errors: [
+                "Unexpected indexed access for the named capturing group 'foo' from regexp result array.",
+                "Unexpected indexed access for the named capturing group 'bar' from regexp result array.",
+                "Unexpected indexed access for the named capturing group 'baz' from regexp result array.",
+                "Unexpected indexed access for the named capturing group 'qux' from regexp result array.",
+            ],
+        },
+        {
+            code: `
+            const match = /(?<foo>foo)/u.exec(str)
+            if (match) {
+                match[1] // <-
+            }
+
+            const match2 = /(?<bar>bar)/u.exec(str)
+            match2
+                ? match2[1] // <-
+                : null;
+
+            const match3 = /(?<baz>baz)/u.exec(str)
+            match3 && match3[1] // <-
+
+            const match4 = /(?<qux>qux)/u.exec(str)
+            if (!match4) {
+            } else {
+                match4[1] // <-
+            }
+            `,
+            output: `
+            const match = /(?<foo>foo)/u.exec(str)
+            if (match) {
+                match.groups.foo // <-
+            }
+
+            const match2 = /(?<bar>bar)/u.exec(str)
+            match2
+                ? match2.groups.bar // <-
+                : null;
+
+            const match3 = /(?<baz>baz)/u.exec(str)
+            match3 && match3.groups.baz // <-
+
+            const match4 = /(?<qux>qux)/u.exec(str)
+            if (!match4) {
+            } else {
+                match4.groups.qux // <-
+            }
+            `,
+            errors: [
+                "Unexpected indexed access for the named capturing group 'foo' from regexp result array.",
+                "Unexpected indexed access for the named capturing group 'bar' from regexp result array.",
+                "Unexpected indexed access for the named capturing group 'baz' from regexp result array.",
+                "Unexpected indexed access for the named capturing group 'qux' from regexp result array.",
+            ],
+        },
     ],
 })