gen-typescript-from-tolk-dev 0.2.4 → 0.3.0

package/dist/types-kernel.js

@@ -1,16 +1,113 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymTable = void 0;
 exports.renderTy = renderTy;
 exports.createLabelsForUnion = createLabelsForUnion;
-exports.instantiateGenerics = instantiateGenerics;
 exports.calcWidthOnStack = calcWidthOnStack;
+const unsupported_errors_1 = require("./unsupported-errors");
 /*
     Contains basic functions working with ABI types,
   which are used both for generating wrappers and dynamic serialization.
-    They do not emit TypeScript expressions and do not depend on CodegenCtx and DynamicCtx.
  */
+// SymTable is an index of ABI symbols: top-level declarations by name and unique types by index.
+class SymTable {
+    constructor(declarations, uniqueTypes, structInstantiations, aliasInstantiations) {
+        this.structs = new Map();
+        this.aliases = new Map();
+        this.enums = new Map();
+        this.uniqueTypes = uniqueTypes;
+        this.structInstantiations = structInstantiations;
+        this.aliasInstantiations = aliasInstantiations;
+        for (const n of declarations) {
+            if (n.kind === 'struct')
+                this.structs.set(n.name, n);
+            else if (n.kind === 'alias')
+                this.aliases.set(n.name, n);
+            else if (n.kind === 'enum')
+                this.enums.set(n.name, n);
+        }
+    }
+    getStruct(structName) {
+        const s = this.structs.get(structName);
+        if (s === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('struct', structName);
+        return s;
+    }
+    getAlias(aliasName) {
+        const a = this.aliases.get(aliasName);
+        if (a === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('alias', aliasName);
+        return a;
+    }
+    getEnum(enumName) {
+        const e = this.enums.get(enumName);
+        if (e === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('enum', enumName);
+        return e;
+    }
+    tyByIdx(tyIdx) {
+        const ty = this.uniqueTypes[tyIdx];
+        if (ty === undefined)
+            throw new unsupported_errors_1.SymbolNotFound('ty_idx', tyIdx.toString());
+        return ty;
+    }
+    // Get fields of a struct, `tyIdx` points to "StructRef".
+    // Simple (non-generic) structs, e.g. `Storage`:
+    // - just return its fields, they all are also non-generic
+    // Generic instantiations, e.g. `Wrapper<int32>`:
+    // - override original ty_idx (potentially generic) from monomorphic instantiations (with Ts substitutes)
+    // - save original ty_idx as uLabelTyIdx in case of generic unions later
+    structFieldsOf(tyIdx) {
+        const ty = this.tyByIdx(tyIdx);
+        if (ty.kind !== 'StructRef') {
+            throw new Error(`expected StructRef at ty_idx=${tyIdx}`);
+        }
+        let fields = this.getStruct(ty.struct_name).fields;
+        let instantiation = this.structInstantiations.find(s => s.ty_idx === tyIdx);
+        if (instantiation) {
+            if (fields.length !== instantiation.monomorphic_fields_ty_idx.length) {
+                throw new Error(`mismatch monomorphic fields size for '${instantiation.struct_name}'`);
+            }
+            fields = fields.map((f, i) => ({
+                ...f,
+                ty_idx: instantiation.monomorphic_fields_ty_idx[i],
+                uLabelTyIdx: f.ty_idx,
+            }));
+        }
+        return fields;
+    }
+    // Get target of an alias, `tyIdx` points to "AliasRef".
+    // Simple (non-generic) aliases, e.g. `AllowedMessages`:
+    // - just return its target
+    // Generic instantiations, e.g. `Either<int8, int16>`:
+    // - override target_ty_idx (potentially generic) from monomorphic instantiations (with Ts substitutes)
+    // - save original target_ty_idx as uLabelTyIdx in case of generic unions later
+    aliasTargetOf(tyIdx) {
+        const ty = this.tyByIdx(tyIdx);
+        if (ty.kind !== 'AliasRef') {
+            throw new Error(`expected AliasRef at ty_idx=${tyIdx}`);
+        }
+        let target = {
+            ty_idx: this.getAlias(ty.alias_name).target_ty_idx,
+        };
+        let instantiation = this.aliasInstantiations.find(a => a.ty_idx === tyIdx);
+        if (instantiation) {
+            target = {
+                ty_idx: instantiation.monomorphic_target_ty_idx,
+                uLabelTyIdx: target.ty_idx,
+            };
+        }
+        return target;
+    }
+}
+exports.SymTable = SymTable;
+// Render `<T>` if a struct/alias is generic.
+function renderTypeArgs(symbols, typeArgsTyIdx) {
+    return typeArgsTyIdx ? `<${typeArgsTyIdx.map(ty_idx => renderTy(symbols, ty_idx)).join(', ')}>` : '';
+}
 // Render intermediate representation back to a valid Tolk type, exactly as it was in original sources.
-function renderTy(ty) {
+function renderTy(symbols, tyIdx) {
+    const ty = symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'int': return `int`;
         case 'intN': return `int${ty.n}`;
@@ -33,24 +130,25 @@ function renderTy(ty) {
         case 'callable': return `continuation`;
         case 'void': return `void`;
         case 'unknown': return `unknown`;
-        case 'nullable': return `${renderTy(ty.inner)}?`;
-        case 'cellOf': return `Cell<${renderTy(ty.inner)}>`;
-        case 'arrayOf': return `array<${renderTy(ty.inner)}>`;
-        case 'lispListOf': return `lisp_list<${renderTy(ty.inner)}>`;
-        case 'tensor': return `(${ty.items.map(renderTy).join(', ')})`;
-        case 'shapedTuple': return `[${ty.items.map(renderTy).join(', ')}]`;
-        case 'mapKV': return `map<${renderTy(ty.k)}, ${renderTy(ty.v)}>`;
+        case 'nullable': return `${renderTy(symbols, ty.inner_ty_idx)}?`;
+        case 'cellOf': return `Cell<${renderTy(symbols, ty.inner_ty_idx)}>`;
+        case 'arrayOf': return `array<${renderTy(symbols, ty.inner_ty_idx)}>`;
+        case 'lispListOf': return `lisp_list<${renderTy(symbols, ty.inner_ty_idx)}>`;
+        case 'tensor': return `(${ty.items_ty_idx.map(ty_idx => renderTy(symbols, ty_idx)).join(', ')})`;
+        case 'shapedTuple': return `[${ty.items_ty_idx.map(ty_idx => renderTy(symbols, ty_idx)).join(', ')}]`;
+        case 'mapKV': return `map<${renderTy(symbols, ty.key_ty_idx)}, ${renderTy(symbols, ty.value_ty_idx)}>`;
         case 'EnumRef': return ty.enum_name;
-        case 'StructRef': return ty.struct_name + (ty.type_args ? `<${ty.type_args.map(renderTy).join(', ')}>` : '');
-        case 'AliasRef': return ty.alias_name + (ty.type_args ? `<${ty.type_args.map(renderTy).join(', ')}>` : '');
+        case 'StructRef': return ty.struct_name + renderTypeArgs(symbols, ty.type_args_ty_idx);
+        case 'AliasRef': return ty.alias_name + renderTypeArgs(symbols, ty.type_args_ty_idx);
         case 'genericT': return ty.name_t;
-        case 'union': return ty.variants.map(v => renderTy(v.variant_ty)).join(' | ');
+        case 'union': return ty.variants.map(v => renderTy(symbols, v.variant_ty_idx)).join(' | ');
     }
 }
 // A "label" is the `$` field in TypeScript output, used to differentiate structs and union variants.
 // Tolk `int32 | int64` -> TS `{ $: 'int32', value: bigint } | { $: 'int64', value: bigint }`.
 // This function creates a string for `$`.
-function createLabel(symbols, ty) {
+function createLabel(symbols, tyIdx) {
+    const ty = symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'int': return `int`;
         case 'intN': return `int${ty.n}`;
@@ -73,7 +171,7 @@ function createLabel(symbols, ty) {
         case 'callable': return `callable`;
         case 'void': return `void`;
         case 'unknown': return `unknown`;
-        case 'nullable': return `${createLabel(symbols, ty.inner)}?`;
+        case 'nullable': return `${createLabel(symbols, ty.inner_ty_idx)}?`;
         case 'cellOf': return `Cell`;
         case 'arrayOf': return `array`;
         case 'lispListOf': return `lisp_list`;
@@ -82,85 +180,70 @@ function createLabel(symbols, ty) {
         case 'mapKV': return `map`;
         case 'EnumRef': return ty.enum_name;
         case 'StructRef': return ty.struct_name;
-        case 'AliasRef': return createLabel(symbols, symbols.getAliasTarget(ty.alias_name));
+        case 'AliasRef': return createLabel(symbols, symbols.aliasTargetOf(tyIdx).ty_idx);
         case 'genericT': return ty.name_t;
-        case 'union': return ty.variants.map(v => createLabel(symbols, v.variant_ty)).join('|');
+        case 'union': return ty.variants.map(v => createLabel(symbols, v.variant_ty_idx)).join('|');
     }
 }
 // Every Tolk struct is generated as TS `interface` with `$` field.
 // Tolk `struct A { ... }` -> TS `interface A { $: 'A', ... }`.
 // So, Tolk `A | B` is represented as TS `A | B` (unlike primitives),
 // because every struct has its own label.
-function isStructWithItsOwnLabel(symbols, ty) {
+function isStructWithItsOwnLabel(symbols, tyIdx) {
+    const ty = symbols.tyByIdx(tyIdx);
     if (ty.kind === 'StructRef')
         return true;
     if (ty.kind === 'AliasRef')
-        return isStructWithItsOwnLabel(symbols, symbols.getAliasTarget(ty.alias_name));
+        return isStructWithItsOwnLabel(symbols, symbols.aliasTargetOf(tyIdx).ty_idx);
     return false;
 }
 // Given a union `T1 | T2 | ...`, calculate a TypeScript representation:
 // whether each variant should be `$ + value` or not, and what string does `$` hold.
-function createLabelsForUnion(symbols, variants) {
-    // in all practical cases, `T_i` is a structure or a primitive;
-    // we try to shorten a label (`createLabel()` is a "simple string of a type"):
+// Parameter `uLabelTyIdx` is set in case of generic instantiations, see a comment inside.
+function createLabelsForUnion(symbols, variants, uLabelTyIdx) {
+    // About uLabelTyIdx:
+    // For example, original (generic) is `struct Or<T1, T2> { uni: T1 | T2 }`.
+    // We have `Or<int32, int64>` with instantiated variants = [ { variant_ty_idx: int32 }, { variant_ty_idx: int64 } ].
+    // But for labels we want not { $: 'int32' } and { $: 'int64' }, but original { $: 'T1' } and { $: 'T2' }.
+    // In this case, uLabelTyIdx points to original (generic) union `T1 | T2`, we have labels from there.
+    let genericVariantsTyIdx;
+    if (uLabelTyIdx !== undefined) {
+        const labelTy = symbols.tyByIdx(uLabelTyIdx);
+        if (labelTy.kind === 'union' && labelTy.variants.length === variants.length) {
+            genericVariantsTyIdx = labelTy.variants.map(v => v.variant_ty_idx);
+        }
+    }
+    // In all practical cases, `T_i` is a structure or a primitive.
+    // We try to shorten a label (`createLabel()` is a "simple string of a type"):
     // - for a generic struct, use `Wrapper`, not `Wrapper<xxx>`
     // - for `Cell<...>`, use a shorthand `Cell`
     // - etc.
-    // but if it results in a duplicate (e.g. `Wrapper<int32> | Wrapper<int64>` => ['Wrapper','Wrapper']),
+    // But if it results in a duplicate (e.g. `Wrapper<int32> | Wrapper<int64>` => ['Wrapper','Wrapper']),
     // then full-string Tolk types are used, and `value` is always required:
     // `type U = { $: 'Wrapper<int32>', value: Wrapper<int32> } | ...`
     let unique = new Set();
     let hasDuplicates = false;
-    variants.forEach(variant => {
-        let labelStr = createLabel(symbols, variant.variant_ty);
+    variants.forEach((variant, i) => {
+        let labelStr = createLabel(symbols, genericVariantsTyIdx?.[i] ?? variant.variant_ty_idx);
         hasDuplicates || (hasDuplicates = unique.has(labelStr));
         unique.add(labelStr);
     });
-    return variants.map(variant => {
-        let variantTy = variant.variant_ty;
-        if (variantTy.kind === 'nullLiteral') {
+    return variants.map((variant, i) => {
+        const labelTyIdx = genericVariantsTyIdx?.[i] ?? variant.variant_ty_idx;
+        const labelTy = symbols.tyByIdx(labelTyIdx);
+        if (labelTy.kind === 'nullLiteral') {
             return { ...variant, labelStr: '', hasValueField: false };
         }
         return {
             ...variant,
-            labelStr: hasDuplicates ? renderTy(variantTy) : createLabel(symbols, variantTy),
-            hasValueField: hasDuplicates ? true : !isStructWithItsOwnLabel(symbols, variantTy)
+            labelStr: hasDuplicates ? renderTy(symbols, labelTyIdx) : createLabel(symbols, labelTyIdx),
+            hasValueField: hasDuplicates ? true : !isStructWithItsOwnLabel(symbols, labelTyIdx)
         };
     });
 }
-// Replace all generic Ts (typeParams) with instantiation (typeArgs) recursively.
-// Example: `(int, T, Wrapper<T?>)` and T=coins => `(int, coins, Wrapper<coins?>)`
-function instantiateGenerics(ty, typeParams, typeArgs) {
-    if (ty.kind === 'nullable')
-        return { ...ty, inner: instantiateGenerics(ty.inner, typeParams, typeArgs) };
-    if (ty.kind === 'cellOf')
-        return { ...ty, inner: instantiateGenerics(ty.inner, typeParams, typeArgs) };
-    if (ty.kind === 'arrayOf')
-        return { ...ty, inner: instantiateGenerics(ty.inner, typeParams, typeArgs) };
-    if (ty.kind === 'lispListOf')
-        return { ...ty, inner: instantiateGenerics(ty.inner, typeParams, typeArgs) };
-    if (ty.kind === 'tensor')
-        return { ...ty, items: ty.items.map(item => instantiateGenerics(item, typeParams, typeArgs)) };
-    if (ty.kind === 'shapedTuple')
-        return { ...ty, items: ty.items.map(item => instantiateGenerics(item, typeParams, typeArgs)) };
-    if (ty.kind === 'mapKV')
-        return { ...ty, k: instantiateGenerics(ty.k, typeParams, typeArgs), v: instantiateGenerics(ty.v, typeParams, typeArgs) };
-    if (ty.kind === 'StructRef')
-        return { ...ty, type_args: ty.type_args?.map(ta => instantiateGenerics(ta, typeParams, typeArgs)) };
-    if (ty.kind === 'AliasRef')
-        return { ...ty, type_args: ty.type_args?.map(ta => instantiateGenerics(ta, typeParams, typeArgs)) };
-    if (ty.kind === 'union')
-        return { ...ty, variants: ty.variants.map(v => ({ ...v, variant_ty: instantiateGenerics(v.variant_ty, typeParams, typeArgs) })) };
-    if (ty.kind === 'genericT') {
-        const idx = typeParams?.indexOf(ty.name_t);
-        if (idx === undefined || idx === -1 || idx >= typeArgs.length)
-            throw new Error(`inconsistent generics: could not find type argument for ${ty.name_t}`);
-        return typeArgs[idx];
-    }
-    return ty;
-}
 // Calculate, how many stack slots a type occupies.
-function calcWidthOnStack(symbols, ty) {
+function calcWidthOnStack(symbols, tyIdx) {
+    const ty = symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'void': {
             // void is like "unit", equal to an empty tensor
@@ -168,24 +251,17 @@ function calcWidthOnStack(symbols, ty) {
         }
         case 'tensor': {
             // a tensor is a sum of its elements
-            return ty.items.map(item => calcWidthOnStack(symbols, item)).reduce((p, c) => p + c, 0);
+            return ty.items_ty_idx.map(ty_idx => calcWidthOnStack(symbols, ty_idx)).reduce((p, c) => p + c, 0);
         }
         case 'StructRef': {
             // a struct is a named tensor: fields one by one;
-            // if a struct is generic `Wrapper<T>`, we have typeArgs T=xxx, and replace T in each field
-            // (it works unless `T` is used in unions)
-            const structRef = symbols.getStruct(ty.struct_name);
-            return structRef.fields.map(f => {
-                const fTy = ty.type_args ? instantiateGenerics(f.ty, structRef.type_params, ty.type_args) : f.ty;
-                return calcWidthOnStack(symbols, fTy);
-            }).reduce((p, c) => p + c, 0);
+            const fields = symbols.structFieldsOf(tyIdx);
+            return fields.map(f => calcWidthOnStack(symbols, f.ty_idx)).reduce((p, c) => p + c, 0);
         }
         case 'AliasRef': {
             // an alias is the same as its underlying (target) type;
-            // if an alias is generic `Maybe<T>`, we have typeArgs T=xxx, and replace T in its target
-            const aliasRef = symbols.getAlias(ty.alias_name);
-            const targetTy = ty.type_args ? instantiateGenerics(aliasRef.target_ty, aliasRef.type_params, ty.type_args) : aliasRef.target_ty;
-            return calcWidthOnStack(symbols, targetTy);
+            const target = symbols.aliasTargetOf(tyIdx);
+            return calcWidthOnStack(symbols, target.ty_idx);
         }
         case 'nullable': {
             // for primitive nullables (common case), like `int?` and `address?`, it's 1 (TVM value or NULL);
@@ -193,7 +269,10 @@ function calcWidthOnStack(symbols, ty) {
             return ty.stack_width ?? 1;
         }
         case 'union': {
-            // for union types, the compiler always inserts stackWidth for simplicity (and stackTypeId for each variant)
+            // for union types, the compiler always inserts stackWidth for non-generic concrete forms
+            if (ty.stack_width === undefined) {
+                throw new Error(`unexpected stack_width=undefined at ty_idx=${tyIdx}`);
+            }
             return ty.stack_width;
         }
         case 'genericT': {

package/dist/unsupported-errors.d.ts

@@ -1,4 +1,3 @@
-import type { Ty } from './abi-types';
 export declare class SymbolNotFound extends Error {
     constructor(symbolKind: string, notFoundName: string);
 }
@@ -9,7 +8,7 @@ export declare class NonStandardDictKey extends Error {
     constructor(message: string);
 }
 export declare class NotSupportedTypeOnStack extends Error {
-    constructor(ty: Ty, fieldPath: string);
+    constructor(tyRendered: string, fieldPath: string);
 }
 export declare class CantGenerateWrappersAtAll extends Error {
     constructor(where: string, prevEx: any);

package/dist/unsupported-errors.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CantCallGetMethodDynamic = exports.CantUnpackDynamic = exports.CantPackDynamic = exports.InvalidDynamicInput = exports.CantGenerateWrappersAtAll = exports.NotSupportedTypeOnStack = exports.NonStandardDictKey = exports.CantGeneratePackUnpack = exports.SymbolNotFound = void 0;
-const types_kernel_1 = require("./types-kernel");
 // Fired when TyRef contains unresolved symbols,
 // e.g. { kind: 'StructRef', struct_name: 'non-existing' }
 class SymbolNotFound extends Error {
@@ -30,8 +29,8 @@ class NonStandardDictKey extends Error {
 exports.NonStandardDictKey = NonStandardDictKey;
 // Some types, like callables/lambdas, can not be used in get methods, we can't generate wrappers then.
 class NotSupportedTypeOnStack extends Error {
-    constructor(ty, fieldPath) {
-        super(`'${fieldPath}' can not be used in get methods, because it contains '${(0, types_kernel_1.renderTy)(ty)}'`);
+    constructor(tyRendered, fieldPath) {
+        super(`'${fieldPath}' can not be used in get methods, because it contains '${tyRendered}'`);
     }
 }
 exports.NotSupportedTypeOnStack = NotSupportedTypeOnStack;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gen-typescript-from-tolk-dev",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Generate TypeScript wrappers from Tolk ABI",
   "author": "TON Core",
   "license": "MIT",