Remove duplicate code and cache JS.Parser instances (#424)

* Remove duplicate code and cache `JS.Parser` instances

* Change sort-alternatives to use getParser

Co-authored-by: yosuke ota <[email protected]>

Author: RunDevelopment

lib/rules/no-dupe-disjunctions.ts

@@ -15,7 +15,7 @@ import {
     fixRemoveCharacterClassElement,
     fixRemoveAlternative,
 } from "../utils"
-import { isCoveredNode, isEqualNodes } from "../utils/regexp-ast"
+import { getParser, isCoveredNode, isEqualNodes } from "../utils/regexp-ast"
 import type { Expression, FiniteAutomaton, NoParent, ReadonlyNFA } from "refa"
 import {
     combineTransformers,
@@ -35,7 +35,6 @@ import {
     getEffectiveMaximumRepetition,
     canReorder,
 } from "regexp-ast-analysis"
-import { RegExpParser } from "regexpp"
 import { UsageOfPattern } from "../utils/get-usage-of-pattern"
 import { mention, mentionChar } from "../utils/mention"
 import type { NestedAlternative } from "../utils/partial-parser"
@@ -964,25 +963,10 @@ export default createRule("no-dupe-disjunctions", {
         function createVisitor(
             regexpContext: RegExpContext,
         ): RegExpVisitor.Handlers {
-            const {
-                patternAst,
-                flagsString,
-                flags,
-                node,
-                getRegexpLocation,
-                getUsageOfPattern,
-            } = regexpContext
-
-            const parser = JS.Parser.fromAst({
-                pattern: patternAst,
-                flags: new RegExpParser().parseFlags(
-                    [
-                        ...new Set(
-                            (flagsString || "").replace(/[^gimsuy]/gu, ""),
-                        ),
-                    ].join(""),
-                ),
-            })
+            const { flags, node, getRegexpLocation, getUsageOfPattern } =
+                regexpContext
+
+            const parser = getParser(regexpContext)
 
             /** Returns the filter information for the given node */
             function getFilterInfo(parentNode: ParentNode): FilterInfo {

lib/rules/no-super-linear-backtracking.ts

@@ -2,10 +2,10 @@ import type { RegExpVisitor } from "regexpp/visitor"
 import type { RegExpContext } from "../utils"
 import { createRule, defineRegexpVisitor } from "../utils"
 import { UsageOfPattern } from "../utils/get-usage-of-pattern"
-import type { ParsedLiteral } from "scslre"
 import { analyse } from "scslre"
 import type { Position, SourceLocation } from "estree"
 import { mention } from "../utils/mention"
+import { getJSRegexppAst } from "../utils/regexp-ast"
 
 /**
  * Returns the combined source location of the two given locations.
@@ -27,31 +27,6 @@ function unionLocations(a: SourceLocation, b: SourceLocation): SourceLocation {
     }
 }
 
-/**
- * Create a parsed literal object as required by the scslre library.
- */
-function getParsedLiteral(context: RegExpContext): ParsedLiteral {
-    const { flags, flagsString, patternAst } = context
-
-    return {
-        pattern: patternAst,
-        flags: {
-            type: "Flags",
-            raw: flagsString ?? "",
-            parent: null,
-            start: NaN,
-            end: NaN,
-            dotAll: flags.dotAll ?? false,
-            global: flags.global ?? false,
-            hasIndices: flags.hasIndices ?? false,
-            ignoreCase: flags.ignoreCase ?? false,
-            multiline: flags.multiline ?? false,
-            sticky: flags.sticky ?? false,
-            unicode: flags.unicode ?? false,
-        },
-    }
-}
-
 export default createRule("no-super-linear-backtracking", {
     meta: {
         docs: {
@@ -102,7 +77,7 @@ export default createRule("no-super-linear-backtracking", {
                 getUsageOfPattern,
             } = regexpContext
 
-            const result = analyse(getParsedLiteral(regexpContext), {
+            const result = analyse(getJSRegexppAst(regexpContext), {
                 reportTypes: { Move: false },
                 assumeRejectingSuffix:
                     reportUncertain &&

lib/rules/no-super-linear-move.ts

@@ -3,7 +3,6 @@ import type { Alternative, Pattern, Quantifier } from "regexpp/ast"
 import type { RegExpContext } from "../utils"
 import { createRule, defineRegexpVisitor } from "../utils"
 import { UsageOfPattern } from "../utils/get-usage-of-pattern"
-import type { ParsedLiteral } from "scslre"
 import { analyse } from "scslre"
 import type { Descendant } from "regexp-ast-analysis"
 import {
@@ -19,40 +18,13 @@ import {
     combineTransformers,
     Transformers,
 } from "refa"
+import { getJSRegexppAst } from "../utils/regexp-ast"
 
 interface Report {
     quant: Quantifier
     attack: string
 }
 
-/**
- * Create a parsed literal object as required by the scslre library.
- */
-function getParsedLiteral(
-    context: RegExpContext,
-    ignoreSticky: boolean,
-): ParsedLiteral {
-    const { flags, flagsString, patternAst } = context
-
-    return {
-        pattern: patternAst,
-        flags: {
-            type: "Flags",
-            raw: flagsString ?? "",
-            parent: null,
-            start: NaN,
-            end: NaN,
-            dotAll: flags.dotAll ?? false,
-            global: flags.global ?? false,
-            hasIndices: flags.hasIndices ?? false,
-            ignoreCase: flags.ignoreCase ?? false,
-            multiline: flags.multiline ?? false,
-            sticky: !ignoreSticky && (flags.sticky ?? false),
-            unicode: flags.unicode ?? false,
-        },
-    }
-}
-
 /**
  * Removes duplicates from the given reports.
  */
@@ -187,7 +159,7 @@ export default createRule("no-super-linear-move", {
         ): Iterable<Report> {
             const { flags } = regexpContext
 
-            const result = analyse(getParsedLiteral(regexpContext, true), {
+            const result = analyse(getJSRegexppAst(regexpContext, true), {
                 reportTypes: { Move: true, Self: false, Trade: false },
                 assumeRejectingSuffix,
             })
@@ -227,7 +199,7 @@ export default createRule("no-super-linear-move", {
             const { patternAst, flags } = regexpContext
 
             const parser = JS.Parser.fromAst(
-                getParsedLiteral(regexpContext, true),
+                getJSRegexppAst(regexpContext, true),
             )
 
             for (const q of findReachableQuantifiers(patternAst)) {

lib/rules/sort-alternatives.ts

@@ -33,8 +33,7 @@ import {
 } from "regexp-ast-analysis"
 import type { CharSet, Word, ReadonlyWord } from "refa"
 import { NFA, JS, transform } from "refa"
-import { getPossiblyConsumedChar } from "../utils/regexp-ast"
-import { RegExpParser } from "regexpp"
+import { getParser, getPossiblyConsumedChar } from "../utils/regexp-ast"
 
 interface AllowedChars {
     allowed: CharSet
@@ -540,28 +539,13 @@ export default createRule("sort-alternatives", {
         function createVisitor(
             regexpContext: RegExpContext,
         ): RegExpVisitor.Handlers {
-            const {
-                node,
-                getRegexpLocation,
-                fixReplaceNode,
-                flags,
-                flagsString,
-                patternAst,
-            } = regexpContext
+            const { node, getRegexpLocation, fixReplaceNode, flags } =
+                regexpContext
 
             const allowedChars = getAllowedChars(flags)
 
             const possibleCharsCache = new Map<Alternative, CharSet>()
-            const parser = JS.Parser.fromAst({
-                pattern: patternAst,
-                flags: new RegExpParser().parseFlags(
-                    [
-                        ...new Set(
-                            (flagsString || "").replace(/[^gimsuy]/gu, ""),
-                        ),
-                    ].join(""),
-                ),
-            })
+            const parser = getParser(regexpContext)
 
             /** A cached version of getPossiblyConsumedChar */
             function getPossibleChars(a: Alternative): CharSet {

lib/utils/regexp-ast/index.ts

@@ -3,6 +3,7 @@ import type { Rule } from "eslint"
 import type { Expression } from "estree"
 import { parseRegExpLiteral, RegExpParser, visitRegExpAST } from "regexpp"
 import { getStaticValue } from "../ast-utils"
+import { JS } from "refa"
 import type { CharRange, CharSet } from "refa"
 import type { ReadonlyFlags } from "regexp-ast-analysis"
 import {
@@ -11,6 +12,7 @@ import {
     isEmptyBackreference,
     toCharSet,
 } from "regexp-ast-analysis"
+import type { RegExpContext } from ".."
 export { ShortCircuit, getFirstConsumedCharPlusAfter } from "./common"
 export * from "./is-covered"
 export * from "./is-equals"
@@ -130,3 +132,46 @@ export function getPossiblyConsumedChar(
 
     return { char, exact }
 }
+
+/**
+ * Create a `JS.RegexppAst` object as required by refa's `JS.Parser.fromAst`
+ * method and `ParsedLiteral` interface of the scslre library.
+ */
+export function getJSRegexppAst(
+    context: RegExpContext,
+    ignoreSticky = false,
+): JS.RegexppAst {
+    const { flags, flagsString, patternAst } = context
+
+    return {
+        pattern: patternAst,
+        flags: {
+            type: "Flags",
+            raw: flagsString ?? "",
+            parent: null,
+            start: NaN,
+            end: NaN,
+            dotAll: flags.dotAll ?? false,
+            global: flags.global ?? false,
+            hasIndices: flags.hasIndices ?? false,
+            ignoreCase: flags.ignoreCase ?? false,
+            multiline: flags.multiline ?? false,
+            sticky: !ignoreSticky && (flags.sticky ?? false),
+            unicode: flags.unicode ?? false,
+        },
+    }
+}
+
+const parserCache = new WeakMap<RegExpContext, JS.Parser>()
+
+/**
+ * Returns a `JS.Parser` for the given regex context.
+ */
+export function getParser(context: RegExpContext): JS.Parser {
+    let cached = parserCache.get(context)
+    if (cached === undefined) {
+        cached = JS.Parser.fromAst(getJSRegexppAst(context))
+        parserCache.set(context, cached)
+    }
+    return cached
+}