fix: failure for toString called as a static function instead of a …

…method (#745)

This required redesigning the compiler context storage implementation,
because it used `Record` type which has `toString` inherited from
`Object.prototype`.
This fix changes `Record` to `Map` to avoid these issues and convey
the meaning in a clearer way.

CHANGELOG.md

@@ -25,6 +25,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Traits can override inherited abstract functions: PR [#724](https://github.com/tact-lang/tact/pull/724)
 - Fix code generation bug for maps from unsigned integers to Boolean values: PR [#725](https://github.com/tact-lang/tact/pull/725)
+- Compiler failure when `toString` gets called as a static function and not a method: PR [#745](https://github.com/tact-lang/tact/pull/745)
 
 ## [1.4.4] - 2024-08-18
 

knip.json

@@ -10,7 +10,6 @@
   "ignoreDependencies": [
     "@tact-lang/ton-abi",
     "@tact-lang/ton-jest",
-    "@types/jest",
-    "dist"
+    "@types/jest"
   ]
 }

src/check.ts

@@ -30,7 +30,7 @@ export function check(args: {
 }): CheckResult {
     // Create context
     const stdlib = createVirtualFileSystem("@stdlib/", files);
-    let ctx: CompilerContext = new CompilerContext({ shared: {} });
+    let ctx: CompilerContext = new CompilerContext();
     ctx = featureEnable(ctx, "debug"); // Enable debug flag (does not affect type checking in practice)
     ctx = featureEnable(ctx, "masterchain"); // Enable masterchain flag to avoid masterchain-specific errors
     ctx = featureEnable(ctx, "external"); // Enable external messages flag to avoid external-specific errors

src/context.ts

@@ -1,49 +1,42 @@
+type Key = string | number;
+export type Store<T> = Map<Key, T>;
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Stores = Map<symbol, Store<any> | undefined>;
+
 export class CompilerContext {
-    readonly shared: Record<symbol, object | undefined> = {};
+    readonly stores: Stores = new Map();
 
     constructor(
-        args: { shared: Record<symbol, object | undefined> } = {
-            shared: {},
+        args: { stores: Stores } = {
+            stores: new Map(),
         },
     ) {
-        this.shared = args.shared;
-        Object.freeze(this.shared);
+        this.stores = args.stores;
+        Object.freeze(this.stores);
         Object.freeze(this);
     }
 
-    addShared = <T>(store: symbol, key: string | number, value: T) => {
-        let sh: Record<string, T> = {};
-        if (this.shared[store]) {
-            sh = { ...this.shared[store] };
-        }
-        sh[key] = value;
-        return new CompilerContext({ shared: { ...this.shared, [store]: sh } });
+    updateStore = <T>(storeDispatch: symbol, key: Key, value: T) => {
+        const store: Store<T> = new Map(this.stores.get(storeDispatch) ?? []);
+        store.set(key, value);
+        const updatedStores = new Map(this.stores);
+        updatedStores.set(storeDispatch, store);
+        return new CompilerContext({ stores: updatedStores });
     };
 }
 
 export function createContextStore<T>() {
     const symbol = Symbol();
     return {
-        get(ctx: CompilerContext, key: string | number) {
-            if (!ctx.shared[symbol]) {
-                return null;
-            }
-            const m = ctx.shared[symbol] as Record<string | number, T>;
-            if (m[key]) {
-                return m[key];
-            } else {
-                return null;
-            }
+        get(ctx: CompilerContext, key: Key): T | null {
+            return ctx.stores.get(symbol)?.get(key) ?? null;
         },
-        all(ctx: CompilerContext): Record<string | number, T> {
-            if (!ctx.shared[symbol]) {
-                return {} as Record<string | number, T>;
-            }
-            const m = ctx.shared[symbol] as Record<string | number, T>;
-            return m;
+        all(ctx: CompilerContext): Store<T> {
+            return ctx.stores.get(symbol) ?? new Map();
         },
-        set(ctx: CompilerContext, key: string | number, v: T) {
-            return ctx.addShared(symbol, key, v);
+        set(ctx: CompilerContext, key: Key, v: T): CompilerContext {
+            return ctx.updateStore(symbol, key, v);
         },
     };
 }

src/generator/createABI.ts

@@ -8,7 +8,7 @@ import { getAllTypes } from "../types/resolveDescriptors";
 import { getAllErrors } from "../types/resolveErrors";
 
 export function createABI(ctx: CompilerContext, name: string): ContractABI {
-    const allTypes = Object.values(getAllTypes(ctx));
+    const allTypes = getAllTypes(ctx);
 
     // Contract
     const contract = allTypes.find((v) => v.name === name);
@@ -39,7 +39,7 @@ export function createABI(ctx: CompilerContext, name: string): ContractABI {
 
     // // Receivers
     const receivers: ABIReceiver[] = [];
-    for (const r of Object.values(contract.receivers)) {
+    for (const r of contract.receivers) {
         if (r.selector.kind === "internal-binary") {
             receivers.push({
                 receiver: "internal",

src/generator/writeProgram.ts

@@ -299,7 +299,7 @@ function writeAll(
     abiLink: string,
 ) {
     // Load all types
-    const allTypes = Object.values(getAllTypes(ctx));
+    const allTypes = getAllTypes(ctx);
     const contracts = allTypes.filter((v) => v.kind === "contract");
     const c = contracts.find((v) => v.name === name);
     if (!c) {
@@ -377,8 +377,7 @@ function writeAll(
     }
 
     // Static functions
-    const sf = getAllStaticFunctions(ctx);
-    Object.values(sf).forEach((f) => {
+    getAllStaticFunctions(ctx).forEach((f) => {
         writeFunction(f, wCtx);
     });
 

src/generator/writers/writeContract.ts

@@ -235,7 +235,7 @@ export function writeMainContract(
         ctx.append(``);
 
         // Write receivers
-        for (const r of Object.values(type.receivers)) {
+        for (const r of type.receivers) {
             writeReceiver(type, r, ctx);
         }
 

src/generator/writers/writeSerialization.spec.ts

@@ -77,7 +77,7 @@ describe("writeSerialization", () => {
                 "user",
                 wCtx,
             );
-            for (const t of Object.values(getAllTypes(ctx))) {
+            for (const t of getAllTypes(ctx)) {
                 if (t.kind === "contract" || t.kind === "struct") {
                     writeAccessors(t, "user", wCtx);
                 }

src/pipeline/build.ts

@@ -61,7 +61,7 @@ export async function build(args: {
     const logger: ILogger = args.logger ?? new Logger();
 
     // Configure context
-    let ctx: CompilerContext = new CompilerContext({ shared: {} });
+    let ctx: CompilerContext = new CompilerContext();
     const cfg: string = JSON.stringify({
         entrypoint: posixNormalize(config.path),
         options: config.options ?? {},

src/storage/resolveAllocation.ts

@@ -1,5 +1,5 @@
 import { CompilerContext, createContextStore } from "../context";
-import { getAllTypes, getType, toBounced } from "../types/resolveDescriptors";
+import { getType, toBounced, getAllTypes } from "../types/resolveDescriptors";
 import { TypeDescription } from "../types/types";
 import { topologicalSort } from "../utils/utils";
 import { StorageAllocation } from "./StorageAllocation";
@@ -12,23 +12,29 @@ import { idText } from "../grammar/ast";
 
 const store = createContextStore<StorageAllocation>();
 
-export function getAllocation(ctx: CompilerContext, name: string) {
+export function getAllocation(
+    ctx: CompilerContext,
+    name: string,
+): StorageAllocation {
     const t = store.get(ctx, name);
     if (!t) {
         throwInternalCompilerError(`Allocation for ${name} not found`);
     }
     return t;
 }
 
-export function getAllocations(ctx: CompilerContext) {
+export function getAllocations(ctx: CompilerContext): {
+    allocation: StorageAllocation;
+    type: TypeDescription;
+}[] {
     return getSortedTypes(ctx).map((v) => ({
         allocation: getAllocation(ctx, v.name),
         type: v,
     }));
 }
 
-export function getSortedTypes(ctx: CompilerContext) {
-    const types = Object.values(getAllTypes(ctx)).filter(
+export function getSortedTypes(ctx: CompilerContext): TypeDescription[] {
+    const types = getAllTypes(ctx).filter(
         (v) => v.kind === "struct" || v.kind === "contract",
     );
     let structs = types.filter((t) => t.kind === "struct");
@@ -54,7 +60,7 @@ export function getSortedTypes(ctx: CompilerContext) {
     return structs;
 }
 
-export function resolveAllocations(ctx: CompilerContext) {
+export function resolveAllocations(ctx: CompilerContext): CompilerContext {
     // Load topological order of structs and contracts
     const types = getSortedTypes(ctx);