fix: SyntaxError message for v flag with RegExpValidator#validatePattern (#110)

Author: ota-meshi

package.json

@@ -53,6 +53,7 @@
     "clean": "rimraf .temp index.*",
     "lint": "eslint . --ext .ts",
     "test": "nyc _mocha \"test/*.ts\" --reporter dot --timeout 10000",
+    "debug": "mocha --require ts-node/register/transpile-only \"test/*.ts\" --reporter dot --timeout 10000",
     "update:test": "ts-node scripts/update-fixtures.ts",
     "update:unicode": "run-s update:unicode:*",
     "update:unicode:ids": "ts-node scripts/update-unicode-ids.ts",

src/regexp-syntax-error.ts

@@ -3,14 +3,16 @@ export class RegExpSyntaxError extends SyntaxError {
 
     public constructor(
         source: string,
-        uFlag: boolean,
+        flags: { unicode: boolean; unicodeSets: boolean },
         index: number,
         message: string,
     ) {
         /*eslint-disable no-param-reassign */
         if (source) {
             if (!source.startsWith("/")) {
-                source = `/${source}/${uFlag ? "u" : ""}`
+                source = `/${source}/${flags.unicode ? "u" : ""}${
+                    flags.unicodeSets ? "v" : ""
+                }`
             }
             source = `: ${source}`
         }

src/validator.ts

@@ -786,7 +786,7 @@ export class RegExpValidator {
               }
             | undefined = undefined,
     ): void {
-        const mode = this._parseFlagsOptionToMode(uFlagOrFlags)
+        const mode = this._parseFlagsOptionToMode(uFlagOrFlags, source, end)
 
         this._unicodeMode = mode.unicodeMode
         this._nFlag = mode.nFlag
@@ -812,7 +812,9 @@ export class RegExpValidator {
                   unicode?: boolean
                   unicodeSets?: boolean
               }
-            | undefined = undefined,
+            | undefined,
+        source: string,
+        sourceEnd: number,
     ): {
         unicodeMode: boolean
         nFlag: boolean
@@ -835,7 +837,12 @@ export class RegExpValidator {
         if (unicode && unicodeSets) {
             // 1. If v is true and u is true, then
             //   a. Let parseResult be a List containing one SyntaxError object.
-            this.raise("Invalid regular expression flags")
+            throw new RegExpSyntaxError(
+                source,
+                { unicode, unicodeSets },
+                sourceEnd + 1 /* `/` */,
+                "Invalid regular expression flags",
+            )
         }
 
         const unicodeMode = unicode || unicodeSets
@@ -1210,7 +1217,10 @@ export class RegExpValidator {
     private raise(message: string): never {
         throw new RegExpSyntaxError(
             this.source,
-            this._unicodeMode,
+            {
+                unicode: this._unicodeMode && !this._unicodeSetsMode,
+                unicodeSets: this._unicodeSetsMode,
+            },
             this.index,
             message,
         )

test/parser.ts

@@ -1,8 +1,16 @@
 import assert from "assert"
-import { parseRegExpLiteral, RegExpParser } from "../src/index"
+import { parseRegExpLiteral, RegExpParser, RegExpValidator } from "../src/index"
 import type { RegExpSyntaxError } from "../src/regexp-syntax-error"
 import { cloneWithoutCircular } from "../scripts/clone-without-circular"
 import { fixturesData } from "./fixtures/parser/literal"
+import {
+    ASTERISK,
+    isLineTerminator,
+    LEFT_SQUARE_BRACKET,
+    REVERSE_SOLIDUS,
+    RIGHT_SQUARE_BRACKET,
+    SOLIDUS,
+} from "../src/unicode"
 
 function generateAST(source: string, options: RegExpParser.Options): object {
     return cloneWithoutCircular(parseRegExpLiteral(source, options))
@@ -56,6 +64,45 @@ describe("parseRegExpLiteral function:", () => {
                         }
                         assert.fail("Should fail, but succeeded.")
                     })
+
+                    const validator = new RegExpValidator(options)
+                    const extracted = extractPatternAndFlags(source, validator)
+                    if (extracted) {
+                        it(`${source} should throw syntax error with RegExpValidator#validatePattern.`, () => {
+                            const expected = result.error
+                            try {
+                                validator.validatePattern(
+                                    extracted.pattern,
+                                    undefined,
+                                    undefined,
+                                    {
+                                        unicode: extracted.flags.includes("u"),
+                                        unicodeSets:
+                                            extracted.flags.includes("v"),
+                                    },
+                                )
+                            } catch (err) {
+                                const error = err as RegExpSyntaxError
+                                const expectedMessage =
+                                    expected.message.replace(
+                                        /\/([a-z]+?):/u,
+                                        (_, flagsInLiteral: string) =>
+                                            `/${flagsInLiteral.replace(
+                                                /[^uv]/gu,
+                                                "",
+                                            )}:`,
+                                    )
+                                const expectedIndex = expected.index - 1
+                                assert.strictEqual(
+                                    error.message,
+                                    expectedMessage,
+                                )
+                                assert.strictEqual(error.index, expectedIndex)
+                                return
+                            }
+                            assert.fail("Should fail, but succeeded.")
+                        })
+                    }
                 }
             }
         })
@@ -79,3 +126,61 @@ describe("RegExpParser:", () => {
         })
     })
 })
+
+function extractPatternAndFlags(
+    source: string,
+    validator: RegExpValidator,
+): { pattern: string; flags: string } | null {
+    let inClass = false
+    let escaped = false
+
+    const chars = [...source]
+
+    if (chars[0] !== "/") {
+        return null
+    }
+    chars.shift()
+
+    const pattern: string[] = []
+
+    let first = true
+    // https://tc39.es/ecma262/2022/multipage/ecmascript-language-lexical-grammar.html#prod-RegularExpressionBody
+    for (;;) {
+        const char = chars.shift()
+        if (!char) {
+            return null
+        }
+        const cp = char.charCodeAt(0)!
+        if (isLineTerminator(cp)) {
+            return null
+        }
+        if (escaped) {
+            escaped = false
+        } else if (cp === REVERSE_SOLIDUS) {
+            escaped = true
+        } else if (cp === LEFT_SQUARE_BRACKET) {
+            inClass = true
+        } else if (cp === RIGHT_SQUARE_BRACKET) {
+            inClass = false
+        } else if (cp === ASTERISK && first) {
+            return null
+        } else if (cp === SOLIDUS && !inClass) {
+            break
+        }
+        pattern.push(char)
+        first = false
+    }
+
+    const flags = chars.join("")
+    if (pattern.length === 0) {
+        return null
+    }
+
+    try {
+        validator.validateFlags(flags)
+    } catch {
+        return null
+    }
+
+    return { pattern: pattern.join(""), flags }
+}