New Func backend: First iteration

.eslintignore

@@ -6,5 +6,7 @@ src/test/**/output/
 src/func/funcfiftlib.js
 src/grammar/grammar.ohm*.ts
 src/grammar/grammar.ohm*.js
+src/func/grammar.ohm*.ts
+src/func/grammar.ohm*.js
 jest.setup.js
-jest.teardown.js
+jest.teardown.js

.gitignore

@@ -7,5 +7,8 @@ dist
 output/
 src/grammar/grammar.ohm-bundle.js
 src/grammar/grammar.ohm-bundle.d.ts
+src/func/grammar.ohm*.ts
+src/func/grammar.ohm*.js
 src/func/funcfiftlib.wasm.js
+src/codegen/contracts/*.config.json
 

.prettierignore

@@ -4,5 +4,7 @@
 /src/func/funcfiftlib.wasm.js
 /src/grammar/grammar.ohm-bundle.d.ts
 /src/grammar/grammar.ohm-bundle.js
+/src/func/grammar.ohm*.ts
+/src/func/grammar.ohm*.js
 /src/imports/stdlib.ts
 /grammar

cspell.json

@@ -33,12 +33,20 @@
     "jettons",
     "jsxdev",
     "langle",
+    "lbrack",
     "lparen",
+    "lquote",
+    "ltick",
     "lvalue",
     "masterchain",
     "maxint",
     "minmax",
     "mintable",
+    "moddiv",
+    "muldiv",
+    "muldivc",
+    "muldivmod",
+    "muldivr",
     "multiformats",
     "Korshakov",
     "nocheck",
@@ -50,15 +58,20 @@
     "Parens",
     "POSIX",
     "prando",
+    "qmark",
     "rangle",
+    "rbrack",
     "rparen",
+    "rquote",
+    "rtick",
     "rugpull",
     "rugpulled",
     "sctx",
     "seqno",
     "shiki",
     "Stateinit",
     "stdlib",
+    "stdump",
     "struct",
     "structs",
     "subtyping",
@@ -84,7 +97,13 @@
     "node_modules",
     "dist",
     "examples/__snapshots__/multisig-3.spec.ts.snap",
-    "func",
+    "/func",
+    "scripts/func",
+    "src/func/__snapshots__/*",
+    "src/func/grammar.ohm*",
+    "src/func/funcfiftlib*",
+    "src/func/grammar-test/*",
+    "src/func/grammar-test-failed/*",
     "grammar/sample.json",
     "src/generator/writers/writeStdlib.ts",
     "src/generator/writers/__snapshots__/writeSerialization.spec.ts.snap",

package.json

@@ -7,13 +7,14 @@
   "author": "Steve Korshakov <[email protected]>",
   "license": "MIT",
   "scripts": {
-    "gen:grammar": "ohm generateBundles --withTypes src/grammar/*.ohm",
+    "gen:grammar": "ohm generateBundles --withTypes src/grammar/*.ohm src/func/*.ohm",
     "gen:pack": "ts-node ./scripts/pack.ts",
     "gen:compiler": "ts-node ./scripts/prepare.ts",
     "gen": "yarn gen:grammar && yarn gen:pack && yarn gen:compiler",
     "clean": "rm -fr dist",
     "build": "tsc && cp ./src/grammar/grammar.ohm* ./dist/grammar/ && cp ./src/func/funcfiftlib.* ./dist/func",
     "test": "jest",
+    "test:func": "yarn gen:grammar && jest -t 'FunC grammar and parser'",
     "coverage": "cross-env COVERAGE=true jest",
     "release": "yarn clean && yarn build && yarn coverage && yarn release-it --npm.yarn1",
     "lint": "yarn eslint .",
@@ -38,9 +39,11 @@
     "@tact-lang/opcode": "^0.0.14",
     "@ton/core": "0.56.3",
     "@ton/crypto": "^3.2.0",
+    "@types/json-bigint": "^1.0.4",
     "blockstore-core": "1.0.5",
     "change-case": "^4.1.2",
     "ipfs-unixfs-importer": "9.0.10",
+    "json-bigint": "^1.0.0",
     "meow": "^13.2.0",
     "mkdirp": "^2.1.3",
     "multiformats": "^13.1.0",

src/codegen/abi.ts

@@ -0,0 +1,26 @@
+import { AstExpression, SrcInfo } from "../grammar/ast";
+import { CompilerContext } from "../context";
+import { TypeRef } from "../types/types";
+import { FuncAstExpression } from "../func/grammar";
+
+/**
+ * A static map of functions defining Func expressions for Tact ABI functions and methods.
+ */
+export type AbiFunction = {
+    name: string;
+    resolve: (ctx: CompilerContext, args: TypeRef[], loc: SrcInfo) => TypeRef;
+    generate: (
+        args: TypeRef[],
+        resolved: AstExpression[],
+        loc: SrcInfo,
+    ) => FuncAstExpression;
+};
+
+// TODO
+export const MapFunctions: Map<string, AbiFunction> = new Map([]);
+
+// TODO
+export const StructFunctions: Map<string, AbiFunction> = new Map([]);
+
+// TODO
+export const GlobalFunctions: Map<string, AbiFunction> = new Map([]);

src/codegen/codegen.spec.ts

@@ -0,0 +1,178 @@
+import * as fs from "fs";
+import * as path from "path";
+
+import { __DANGER_resetNodeId } from "../grammar/ast";
+import { compile } from "../pipeline/compile";
+import { precompile } from "../pipeline/precompile";
+import { getContracts } from "../types/resolveDescriptors";
+import { CompilationOutput, CompilationResults } from "../pipeline/compile";
+import { createNodeFileSystem } from "../vfs/createNodeFileSystem";
+import { CompilerContext } from "../context";
+
+const CONTRACTS_DIR = path.join(__dirname, "./contracts/");
+
+function capitalize(str: string): string {
+    if (str.length === 0) return str;
+    return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+}
+
+/**
+ * Generates a Tact configuration file for the given contract (imported from Misti).
+ */
+export function generateConfig(contractName: string): string {
+    const config = {
+        projects: [
+            {
+                name: `${contractName}`,
+                path: `./${contractName}.tact`,
+                output: `./output`,
+                options: {},
+            },
+        ],
+    };
+    const configPath = path.join(CONTRACTS_DIR, `${contractName}.config.json`);
+    fs.writeFileSync(configPath, JSON.stringify(config), {
+        encoding: "utf8",
+        flag: "w",
+    });
+    return configPath;
+}
+
+/**
+ * Compiles the contract on the given filepath to CompilationResults replicating the Tact compiler pipeline.
+ */
+async function compileContract(
+    backend: "new" | "old",
+    contractName: string,
+): Promise<CompilationResults[]> {
+    const _ = generateConfig(contractName);
+
+    // see: pipeline/build.ts
+    const project = createNodeFileSystem(CONTRACTS_DIR, false);
+    const stdlib = createNodeFileSystem(
+        path.resolve(__dirname, "..", "..", "stdlib"),
+        false,
+    );
+    let ctx: CompilerContext = new CompilerContext({ shared: {} });
+    ctx = precompile(ctx, project, stdlib, contractName);
+
+    return await Promise.all(
+        getContracts(ctx).map(async (contract) => {
+            const res = await compile(
+                ctx,
+                contract,
+                `${contractName}_${contract}`,
+                backend,
+            );
+            return res;
+        }),
+    );
+}
+
+function compareCompilationOutputs(
+    newOut: CompilationOutput,
+    oldOut: CompilationOutput,
+): void {
+    const errors: string[] = [];
+
+    if (newOut === undefined || oldOut === undefined) {
+        errors.push("One of the outputs is undefined.");
+    } else {
+        try {
+            expect(newOut.entrypoint).toBe(oldOut.entrypoint);
+        } catch (error) {
+            if (error instanceof Error) {
+                errors.push(`Entrypoint mismatch: ${error.message}`);
+            } else {
+                errors.push(`Entrypoint mismatch: ${String(error)}`);
+            }
+        }
+
+        try {
+            expect(newOut.abi).toBe(oldOut.abi);
+        } catch (error) {
+            if (error instanceof Error) {
+                errors.push(`ABI mismatch: ${error.message}`);
+            } else {
+                errors.push(`ABI mismatch: ${String(error)}`);
+            }
+        }
+
+        const unmatchedFiles = new Set(oldOut.files.map((file) => file.name));
+
+        for (const newFile of newOut.files) {
+            const oldFile = oldOut.files.find(
+                (file) => file.name === newFile.name,
+            );
+            if (oldFile) {
+                unmatchedFiles.delete(oldFile.name);
+                try {
+                    expect(newFile.code).toBe(oldFile.code);
+                } catch (error) {
+                    if (error instanceof Error) {
+                        errors.push(
+                            `Code mismatch in file ${newFile.name}: ${error.message}`,
+                        );
+                    } else {
+                        errors.push(
+                            `Code mismatch in file ${newFile.name}: ${String(error)}`,
+                        );
+                    }
+                }
+            } else {
+                errors.push(
+                    `File ${newFile.name} is missing in the old output.`,
+                );
+            }
+        }
+
+        for (const missingFile of unmatchedFiles) {
+            errors.push(`File ${missingFile} is missing in the new output.`);
+        }
+    }
+
+    if (errors.length > 0) {
+        throw new Error(errors.join("\n"));
+    }
+}
+
+describe("codegen", () => {
+    beforeEach(async () => {
+        __DANGER_resetNodeId();
+    });
+
+    fs.readdirSync(CONTRACTS_DIR).forEach((file) => {
+        if (!file.endsWith(".tact")) {
+            return;
+        }
+        const contractName = capitalize(file);
+        // Differential tests with the old backend
+        it(`Should compile the ${file} contract`, async () => {
+            Promise.all([
+                compileContract("new", contractName),
+                compileContract("old", contractName),
+            ])
+                .then(([resultsNew, resultsOld]) => {
+                    if (resultsNew.length !== resultsOld.length) {
+                        throw new Error("Not all contracts have been compiled");
+                    }
+                    const zipped = resultsNew.map((value, idx) => [
+                        value,
+                        resultsOld[idx],
+                    ]);
+                    zipped.forEach(([newRes, oldRes]) => {
+                        compareCompilationOutputs(
+                            newRes!.output,
+                            oldRes!.output,
+                        );
+                    });
+                })
+                .catch((error) => {
+                    console.error(
+                        "An error occurred during compilation:",
+                        error,
+                    );
+                });
+        });
+    });
+});