Fix incorrect pattern parsing when giving RegExp argument to RegExp constructor (#259)

Author: ota-meshi

lib/rules/no-useless-flag.ts

@@ -176,7 +176,10 @@ function getFlagLocation(
             end: sourceCode.getLocFromIndex(flagIndex + 1),
         }
     }
-    return node.arguments[1].loc!
+    if (node.arguments.length >= 2) {
+        return node.arguments[1].loc!
+    }
+    return context.getSourceCode().getTokenAfter(node.arguments[0])!.loc!
 }
 
 /**

lib/utils/index.ts

@@ -6,7 +6,7 @@ import { RegExpParser, visitRegExpAST } from "regexpp"
 import { CALL, CONSTRUCT, ReferenceTracker } from "eslint-utils"
 import type { Rule, AST, SourceCode } from "eslint"
 import { parseStringTokens } from "./string-literal-parser"
-import { findVariable, getStringIfConstant } from "./ast-utils"
+import { findVariable, getStaticValue, getStringIfConstant } from "./ast-utils"
 import type { ReadonlyFlags, ToCharSetElement } from "regexp-ast-analysis"
 // eslint-disable-next-line no-restricted-imports -- Implement RegExpContext#toCharSet
 import { toCharSet } from "regexp-ast-analysis"
@@ -338,6 +338,7 @@ function buildRegexpVisitor(
                 pattern: string | null
                 flagsNode: ESTree.Expression | ESTree.SpreadElement | undefined
                 flagsString: string | null
+                ownsFlags: boolean
             }[] = []
             for (const { node } of tracker.iterateGlobalReferences({
                 RegExp: { [CALL]: true, [CONSTRUCT]: true },
@@ -349,25 +350,47 @@ function buildRegexpVisitor(
                 if (!patternNode || patternNode.type === "SpreadElement") {
                     continue
                 }
-                const pattern = getStringIfConstant(context, patternNode)
-                const flagsString = flagsNode
-                    ? getStringIfConstant(context, flagsNode)
-                    : null
+                const patternResult = getStaticValue(context, patternNode)
+                if (!patternResult || patternResult.value == null) {
+                    continue
+                }
+                let pattern: string | null = null
+                let { flagsString, ownsFlags } =
+                    flagsNode && flagsNode.type !== "SpreadElement"
+                        ? {
+                              flagsString: getStringIfConstant(
+                                  context,
+                                  flagsNode,
+                              ),
+                              ownsFlags: isStringLiteral(flagsNode),
+                          }
+                        : { flagsString: null, ownsFlags: false }
+                if (patternResult.value instanceof RegExp) {
+                    pattern = patternResult.value.source
+                    if (!flagsNode) {
+                        // If no flag is given, the flag is also cloned.
+                        flagsString = patternResult.value.flags
+                        ownsFlags = true
+                    }
+                } else {
+                    pattern = String(patternResult.value)
+                }
 
                 regexpDataList.push({
                     newOrCall,
                     patternNode,
                     pattern,
                     flagsNode,
                     flagsString,
+                    ownsFlags,
                 })
             }
             for (const {
                 newOrCall,
                 patternNode,
                 pattern,
-                flagsNode,
                 flagsString,
+                ownsFlags,
             } of regexpDataList) {
                 if (typeof pattern === "string") {
                     let verifyPatternNode = patternNode
@@ -421,11 +444,7 @@ function buildRegexpVisitor(
                                 pattern,
                                 flags,
                                 flagsString,
-                                ownsFlags: Boolean(
-                                    flagsNode &&
-                                        flagsNode.type !== "SpreadElement" &&
-                                        isStringLiteral(flagsNode),
-                                ),
+                                ownsFlags,
                                 regexpNode: newOrCall,
                                 ...helpers,
                                 getRegexpRange: (regexpNode) =>

tests/lib/rules/no-useless-assertions.ts

@@ -50,6 +50,12 @@ tester.run("no-useless-assertions", rule as any, {
         // exponentially for nested loops. In this case, the 48 nested loops necessitate 2.8e14 starting positions.
         // There needs to be some optimization to work around this problem.
         String.raw`/((((((((((((((((((((((((((((((((((((((((((((((((\b)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+)+/`,
+
+        // https://github.com/ota-meshi/eslint-plugin-regexp/issues/258
+        String.raw`
+        const orig = /^https?:\/\//i;
+        const clone = new RegExp(orig);
+        `,
     ],
     invalid: [
         {

tests/lib/rules/no-useless-flag.ts

@@ -568,6 +568,77 @@ tester.run("no-useless-flag", rule as any, {
                 },
             ],
         },
+
+        // test for RegExp constructor with RegExp arguments
+        {
+            code: String.raw`
+            const orig = /\w/i; // eslint-disable-line
+            const clone = new RegExp(orig);
+            `,
+            output: null,
+            errors: [
+                {
+                    message:
+                        "The 'i' flag is unnecessary because the pattern only contains case-invariant characters.",
+                    line: 3,
+                    column: 42,
+                },
+            ],
+        },
+        {
+            code: String.raw`
+            const orig = /\w/i; // eslint-disable-line
+            const clone = new RegExp(orig, 'i');
+            `,
+            output: String.raw`
+            const orig = /\w/i; // eslint-disable-line
+            const clone = new RegExp(orig, '');
+            `,
+            errors: [
+                {
+                    message:
+                        "The 'i' flag is unnecessary because the pattern only contains case-invariant characters.",
+                    line: 3,
+                    column: 44,
+                },
+            ],
+        },
+        {
+            code: String.raw`
+            const orig = /\w/i;
+            const clone = new RegExp(orig, '');
+            `,
+            output: String.raw`
+            const orig = /\w/;
+            const clone = new RegExp(orig, '');
+            `,
+            errors: [
+                {
+                    message:
+                        "The 'i' flag is unnecessary because the pattern only contains case-invariant characters.",
+                    line: 2,
+                    column: 30,
+                },
+            ],
+        },
+        {
+            code: String.raw`
+            const orig = /\w/;
+            const clone = new RegExp(orig, 'i');
+            `,
+            output: String.raw`
+            const orig = /\w/;
+            const clone = new RegExp(orig, '');
+            `,
+            errors: [
+                {
+                    message:
+                        "The 'i' flag is unnecessary because the pattern only contains case-invariant characters.",
+                    line: 3,
+                    column: 44,
+                },
+            ],
+        },
     ],
 })