Draft: pretty-printer tests with randomly generated AST Expressions

.eslintignore

@@ -8,5 +8,6 @@ src/func/funcfiftlib.js
 **/grammar.ohm*.js
 src/grammar/next/grammar.ts
 jest.setup.js
+jest.globalSetup.js
 jest.teardown.js
 /docs

cspell.json

@@ -133,7 +133,8 @@
     "Ints",
     "workchain",
     "xffff",
-    "привет"
+    "привет",
+    "letrec"
   ],
   "ignoreRegExpList": [
     "\\b[xB]\\{[a-fA-F0-9]*_?\\}", // binary literals in Fift-asm

jest.config.js

@@ -3,7 +3,8 @@ module.exports = {
     testEnvironment: "node",
     testPathIgnorePatterns: ["/node_modules/", "/dist/"],
     maxWorkers: "50%",
-    globalSetup: "./jest.setup.js",
+    globalSetup: "./jest.globalSetup.js",
+    setupFiles: ["./jest.setup.js"],
     globalTeardown: "./jest.teardown.js",
     snapshotSerializers: ["@tact-lang/ton-jest/serializers"],
 };

jest.globalSetup.js

@@ -0,0 +1,8 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const coverage = require("@tact-lang/coverage");
+
+module.exports = async () => {
+    if (process.env.COVERAGE === "true") {
+        coverage.beginCoverage();
+    }
+};

jest.setup.js

@@ -1,8 +1,51 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const coverage = require("@tact-lang/coverage");
+const fc = require("fast-check");
 
-module.exports = async () => {
-    if (process.env.COVERAGE === "true") {
-        coverage.beginCoverage();
+function sanitizeObject(
+    obj,
+    options = {
+        excludeKeys: [],
+        valueTransformers: {},
+    },
+) {
+    const { excludeKeys, valueTransformers } = options;
+
+    if (Array.isArray(obj)) {
+        return obj.map((item) => sanitizeObject(item, options));
+    } else if (obj !== null && typeof obj === "object") {
+        const newObj = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (!excludeKeys.includes(key)) {
+                const transformer = valueTransformers[key];
+                newObj[key] = transformer
+                    ? transformer(value)
+                    : sanitizeObject(value, options);
+            }
+        }
+        return newObj;
     }
-};
+    return obj;
+}
+
+fc.configureGlobal({
+    reporter: (log) => {
+        if (log.failed) {
+            const sanitizedCounterexample = sanitizeObject(log.counterexample, {
+                excludeKeys: ["id", "loc"],
+                valueTransformers: {
+                    value: (val) =>
+                        typeof val === "bigint" ? val.toString() : val,
+                },
+            });
+
+            const errorMessage = `
+      Property failed after ${log.numRuns} tests
+      Seed: ${log.seed}
+      Path: ${log.counterexamplePath}
+      Counterexample: ${JSON.stringify(sanitizedCounterexample, null, 0)}
+      Errors: ${log.error ? log.error : "Unknown error"}
+            `;
+
+            throw new Error(errorMessage);
+        }
+    },
+});

package.json

@@ -87,6 +87,7 @@
     "cross-env": "^7.0.3",
     "cspell": "^8.8.3",
     "eslint": "^8.56.0",
+    "fast-check": "^3.23.2",
     "glob": "^8.1.0",
     "husky": "^9.1.5",
     "jest": "^29.3.1",

src/test/prettyPrint/expressions.spec.ts

@@ -0,0 +1,72 @@
+import fc from "fast-check";
+import { AstExpression, eqExpressions, getAstFactory } from "../../ast/ast";
+import { prettyPrint } from "../../prettyPrinter";
+import { getParser } from "../../grammar";
+import {
+    randomAstConditional,
+    randomAstOpBinary,
+    randomAstOpUnary,
+    randomAstExpression,
+    randomAstInitOf,
+    randomAstNull,
+    randomAstStaticCall,
+    randomAstStructInstance,
+    randomAstStructFieldInitializer,
+    randomAstId,
+    randomAstFieldAccess,
+    randomAstMethodCall,
+    randomAstBoolean,
+    randomAstNumber,
+    randomAstString,
+} from "../utils/expression/randomAst";
+
+describe("Pretty Print Expressions", () => {
+    const maxDepth = 3;
+    const expression = () => randomAstExpression(maxDepth);
+
+    const cases: [string, fc.Arbitrary<AstExpression>][] = [
+        //
+        // Primary expressions
+        //
+        ["AstMethodCall", randomAstMethodCall(expression(), expression())],
+        ["AstFieldAccess", randomAstFieldAccess(expression())],
+        ["AstStaticCall", randomAstStaticCall(expression())],
+        [
+            "AstStructInstance",
+            randomAstStructInstance(
+                randomAstStructFieldInitializer(expression()),
+            ),
+        ],
+        ["AstId", randomAstId()],
+        ["AstNull", randomAstNull()],
+        ["AstInitOf", randomAstInitOf(expression())],
+        ["AstString", randomAstString()],
+
+        //
+        // Literals
+        //
+        ["AstNumber", randomAstNumber()],
+        ["AstBoolean", randomAstBoolean()],
+
+        [
+            "AstConditional",
+            randomAstConditional(expression(), expression(), expression()),
+        ],
+        ["AstOpBinary", randomAstOpBinary(expression(), expression())],
+        ["AstOpUnary", randomAstOpUnary(expression())],
+    ];
+
+    cases.forEach(([caseName, astGenerator]) => {
+        it(`should parse ${caseName}`, () => {
+            fc.assert(
+                fc.property(astGenerator, (generatedAst) => {
+                    const prettyBefore = prettyPrint(generatedAst);
+                    const parser = getParser(getAstFactory(), "new");
+                    const parsedAst = parser.parseExpression(prettyBefore);
+                    expect(eqExpressions(generatedAst, parsedAst)).toBe(true);
+                }),
+                { seed: 1 },
+            );
+        });
+    });
+});