chore(test): add test cases for regex literals extracted from test262 (#100)

Author: ota-meshi

.eslintrc.js

@@ -49,6 +49,15 @@ module.exports = {
                 "@eslint-community/mysticatea/ts/no-unsafe-return": "off",
             },
         },
+        {
+            files: ["./scripts/extract-test262.ts"],
+            // Disables rules that cannot resolve reports due to missing library type definitions.
+            rules: {
+                "@eslint-community/mysticatea/ts/ban-ts-comment": "off",
+                "@eslint-community/mysticatea/ts/no-unsafe-assignment": "off",
+                "@eslint-community/mysticatea/ts/no-unsafe-call": "off",
+            },
+        },
 
         {
             files: "./src/unicode/ids.ts",

.github/workflows/cron.yml

@@ -22,3 +22,21 @@ jobs:
         run: |
             git add --all && \
             git diff-index --cached HEAD --stat --exit-code
+  check-extract-test262:
+    name: check-extract-test262
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - name: Install Packages
+        run: npm install
+      - name: Update
+        run: npm run update:test262:extract
+      - name: Check changes
+        run: |
+            git add --all && \
+            git diff-index --cached HEAD --stat --exit-code

package.json

@@ -57,6 +57,7 @@
     "update:unicode": "run-s update:unicode:*",
     "update:unicode:ids": "ts-node scripts/update-unicode-ids.ts",
     "update:unicode:props": "ts-node scripts/update-unicode-properties.ts",
+    "update:test262:extract": "ts-node -T scripts/extract-test262.ts",
     "preversion": "npm test && npm run -s build",
     "postversion": "git push && git push --tags",
     "prewatch": "npm run -s clean",
@@ -72,13 +73,16 @@
     "@types/node": "^12.20.55",
     "dts-bundle": "^0.7.3",
     "eslint": "^8.31.0",
+    "js-tokens": "^8.0.1",
     "jsdom": "^19.0.0",
     "mocha": "^9.2.2",
     "npm-run-all": "^4.1.5",
     "nyc": "^14.1.1",
     "rimraf": "^3.0.2",
     "rollup": "^2.79.1",
     "rollup-plugin-sourcemaps": "^0.6.3",
+    "test262": "git+https://github.com/tc39/test262.git",
+    "test262-stream": "^1.4.0",
     "ts-node": "^10.9.1",
     "typescript": "~5.0.2"
   },

scripts/extract-test262.ts

@@ -0,0 +1,161 @@
+// @ts-ignore -- ignore
+import TestStream from "test262-stream"
+import path from "path"
+import { promises as fs } from "fs"
+import { parseRegExpLiteral } from "../src/index"
+import jsTokens from "js-tokens"
+import { cloneWithoutCircular } from "./clone-without-circular"
+import type { RegExpSyntaxError } from "../src/regexp-syntax-error"
+import { fixturesData } from "../test/fixtures/parser/literal"
+import type { Readable } from "stream"
+
+const fixturesRoot = path.join(
+    __dirname,
+    "../test/fixtures/parser/literal/test262",
+)
+
+const test262Root = path.dirname(require.resolve("test262/package.json"))
+
+const stream: Readable = new TestStream(test262Root, { omitRuntime: true })
+
+type Test = {
+    file: string
+    contents: string
+    attrs: {
+        features?: string[]
+    }
+}
+
+const testObjects: Test[] = []
+
+stream.on("data", (test: Test) => {
+    if (!test.file.toLocaleLowerCase().includes("regexp")) {
+        return
+    }
+    testObjects.push(test)
+})
+stream.on("end", () => {
+    // eslint-disable-next-line no-void
+    void extractMain()
+})
+
+async function extractMain() {
+    const usedPatterns = new Set<string>()
+    for (const fixture of Object.values(fixturesData)) {
+        for (const pattern of Object.keys(fixture.patterns)) {
+            usedPatterns.add(pattern)
+        }
+    }
+    const extractedFixtures = new Map<
+        string,
+        {
+            _test262FileNames: string[]
+            options: {
+                strict?: boolean
+            }
+            patterns: Record<string, any>
+        }
+    >()
+    for (const test of testObjects.sort((a, b) => {
+        const lengthA = a.attrs.features?.length ?? 999
+        const lengthB = b.attrs.features?.length ?? 999
+        return lengthA - lengthB || compareStr(a.file, b.file)
+    })) {
+        let filePath: string | undefined = undefined
+        if (test.attrs.features && test.attrs.features.length > 0) {
+            filePath = path.join(
+                fixturesRoot,
+                `${[...test.attrs.features]
+                    .sort(compareStr)
+                    .join("-and-")}.json`,
+            )
+        } else {
+            filePath = path.join(fixturesRoot, "not-categorized.json")
+        }
+        let fixture = extractedFixtures.get(filePath)
+
+        if (!fixture) {
+            if (await fileExists(filePath)) {
+                fixture = JSON.parse(await fs.readFile(filePath, "utf8"))
+            }
+            if (!fixture) {
+                fixture = {
+                    _test262FileNames: [],
+                    options: {},
+                    patterns: {},
+                }
+                extractedFixtures.set(filePath, fixture)
+            }
+        }
+        let has = false
+        for (const pattern of extractRegExp(test.contents)) {
+            if (usedPatterns.has(pattern)) {
+                continue
+            }
+            has = true
+            usedPatterns.add(pattern)
+            try {
+                const ast = parseRegExpLiteral(pattern, fixture.options)
+                fixture.patterns[pattern] = { ast: cloneWithoutCircular(ast) }
+            } catch (err) {
+                const error = err as RegExpSyntaxError
+                fixture.patterns[pattern] = {
+                    error: { message: error.message, index: error.index },
+                }
+            }
+        }
+        if (has) {
+            fixture._test262FileNames = [
+                ...fixture._test262FileNames,
+                test.file,
+            ]
+        }
+    }
+    await fs.copyFile(
+        path.join(test262Root, "LICENSE"),
+        path.join(fixturesRoot, "LICENSE"),
+    )
+    for (const [filePath, fixture] of extractedFixtures) {
+        if (Object.keys(fixture.patterns).length === 0) {
+            continue
+        }
+        fixture._test262FileNames = [
+            ...new Set(fixture._test262FileNames),
+        ].sort(compareStr)
+        // @ts-ignore -- ignore
+        fixture.patterns = Object.fromEntries(
+            Object.entries(fixture.patterns).sort((a, b) =>
+                compareStr(a[0], b[0]),
+            ),
+        )
+        await fs.mkdir(path.dirname(filePath), { recursive: true })
+        await fs.writeFile(
+            filePath,
+            JSON.stringify(
+                fixture,
+                (_, v: unknown) => (v === Infinity ? "$$Infinity" : v),
+                2,
+            ),
+        )
+    }
+}
+
+function* extractRegExp(content: string) {
+    for (const token of jsTokens(content)) {
+        if (token.type === "RegularExpressionLiteral") {
+            yield token.value
+        }
+    }
+}
+
+async function fileExists(filepath: string) {
+    try {
+        return (await fs.lstat(filepath)).isFile()
+    } catch (e) {
+        return false
+    }
+}
+
+function compareStr(a: string, b: string) {
+    return a > b ? 1 : a < b ? -1 : 0
+}

test/fixtures/parser/literal.ts

@@ -18,7 +18,7 @@ type FixtureData = Record<
 
 export const fixturesData: FixtureData = {}
 const fixturesRoot = path.join(__dirname, "literal")
-for (const filename of fs.readdirSync(fixturesRoot)) {
+for (const filename of extractFixtureFiles(fixturesRoot)) {
     fixturesData[filename] = JSON.parse(
         fs.readFileSync(path.join(fixturesRoot, filename), "utf8"),
         (_, v: unknown) => (v === "$$Infinity" ? Infinity : v),
@@ -37,3 +37,17 @@ export function save(): void {
         )
     }
 }
+
+function* extractFixtureFiles(dir: string): Iterable<string> {
+    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (dirent.isDirectory()) {
+            for (const name of extractFixtureFiles(
+                path.join(dir, dirent.name),
+            )) {
+                yield path.join(dirent.name, name)
+            }
+        } else if (dirent.name.endsWith(".json")) {
+            yield dirent.name
+        }
+    }
+}

test/fixtures/parser/literal/test262/LICENSE

@@ -0,0 +1,28 @@
+The << Software identified by reference to the Ecma Standard* ("Software)">>  is protected by copyright and is being 
+made available under the  "BSD License", included below. This Software may be subject to third party rights (rights 
+from parties other than Ecma International), including patent rights, and no licenses under such third party rights 
+are granted under this license even if the third party concerned is a member of Ecma International.  SEE THE ECMA 
+CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT http://www.ecma-international.org/memento/codeofconduct.htm FOR 
+INFORMATION REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA INTERNATIONAL STANDARDS*.
+
+Copyright (C) 2012-2013 Ecma International
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the 
+following conditions are met:
+1.   Redistributions of source code must retain the above copyright notice, this list of conditions and the following 
+     disclaimer.
+2.   Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the 
+     following disclaimer in the documentation and/or other materials provided with the distribution.
+3.   Neither the name of the authors nor Ecma International may be used to endorse or promote products derived from 
+     this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
+SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 
+DAMAGE.
+
+* Ecma International Standards hereafter means Ecma International Standards as well as Ecma Technical Reports