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

package/dist/emit-pack-unpack.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitLoadOfStruct = emitLoadOfStruct;
+exports.emitLoadOfAlias = emitLoadOfAlias;
+exports.emitLoadOfEnum = emitLoadOfEnum;
 exports.emitLoadExpr = emitLoadExpr;
 exports.emitLoadCallback = emitLoadCallback;
+exports.emitStoreOfStruct = emitStoreOfStruct;
+exports.emitStoreOfAlias = emitStoreOfAlias;
+exports.emitStoreOfEnum = emitStoreOfEnum;
 exports.emitStoreStatement = emitStoreStatement;
 exports.emitStoreCallback = emitStoreCallback;
 exports.emitMakeCellFromExpr = emitMakeCellFromExpr;
@@ -12,10 +18,49 @@ const emit_ts_types_1 = require("./emit-ts-types");
 const formatting_1 = require("./formatting");
 const unsupported_errors_1 = require("./unsupported-errors");
 const types_kernel_1 = require("./types-kernel");
+// Emit body of `SomeStruct.fromSlice` method.
+// Also called to load `Wrapper<int32>`, because `fromSlice` is not generated for generics, they are in-place (monomorphization).
+function emitLoadOfStruct(ctx, structRef, instantiationTyIdx) {
+    if (structRef.custom_pack_unpack?.pack_to_builder) {
+        return `return invokeCustomUnpackFromSlice<${(0, formatting_1.safeJsIdent)(structRef.name)}>('${structRef.name}', s);`;
+    }
+    let buf = new formatting_1.OutBuf();
+    if (structRef.prefix && structRef.prefix.prefix_len === 32) {
+        buf.push(`${codegen_ctx_1.RUNTIME.loadAndCheckPrefix32}(s, ${(0, emit_ts_types_1.emitPrefixHex)(structRef.prefix)}, '${structRef.name}');`);
+    }
+    else if (structRef.prefix) {
+        ctx.has_non32Prefixes = true;
+        buf.push(`${codegen_ctx_1.RUNTIME.loadAndCheckPrefix}(s, ${(0, emit_ts_types_1.emitPrefixHex)(structRef.prefix)}, ${structRef.prefix.prefix_len}, '${structRef.name}');`);
+    }
+    buf.push(`return {`);
+    buf.push(`$: '${structRef.name}',`);
+    for (let f of ctx.symbols.structFieldsOf(instantiationTyIdx)) {
+        buf.push(`${(0, formatting_1.safeFieldDecl)(f.name)}: ${emitLoadExpr(ctx, `${(0, formatting_1.safeJsIdent)(structRef.name)}${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty_idx, f.uLabelTyIdx)},`);
+    }
+    buf.push('}');
+    return buf.toString();
+}
+// Emit body of `SomeAlias.fromSlice` method.
+// Also called to load `Either<int32, int64>`, because `fromSlice` is not generated for generics.
+function emitLoadOfAlias(ctx, aliasRef, instantiationTyIdx) {
+    if (aliasRef.custom_pack_unpack?.unpack_from_slice) {
+        return `return invokeCustomUnpackFromSlice<${(0, formatting_1.safeJsIdent)(aliasRef.name)}>('${aliasRef.name}', s);`;
+    }
+    let target = ctx.symbols.aliasTargetOf(instantiationTyIdx);
+    return `return ${emitLoadExpr(ctx, aliasRef.name, target.ty_idx, target.uLabelTyIdx)};`;
+}
+// Emit body of `SomeEnum.fromSlice` method.
+function emitLoadOfEnum(ctx, enumRef) {
+    if (enumRef.custom_pack_unpack?.unpack_from_slice) {
+        return `return invokeCustomUnpackFromSlice<${(0, formatting_1.safeJsIdent)(enumRef.name)}>('${enumRef.name}', s);`;
+    }
+    return `return ${emitLoadExpr(ctx, enumRef.name, enumRef.encoded_as_ty_idx)};`;
+}
 // Emit a TS "load {ty} from slice `s`" expression.
 // Parameter `fieldPath` is used for error messages only: e.g. when an input opcode is incorrect,
 // the fired Error will contain struct/field name.
-function emitLoadExpr(ctx, fieldPath, ty) {
+function emitLoadExpr(ctx, fieldPath, tyIdx, uLabelTyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'int':
         case 'builder':
@@ -25,7 +70,7 @@ function emitLoadExpr(ctx, fieldPath, ty) {
             let hint = ty.kind === 'int' ? ' (not int32/uint64/etc.)' :
                 ty.kind === 'builder' || ty.kind === 'slice' ? ' (it can be used for writing only)' :
                     '';
-            throw new unsupported_errors_1.CantGeneratePackUnpack(`'${fieldPath}' is '${(0, types_kernel_1.renderTy)(ty)}'${hint}`);
+            throw new unsupported_errors_1.CantGeneratePackUnpack(`'${fieldPath}' is '${(0, types_kernel_1.renderTy)(ctx.symbols, tyIdx)}'${hint}`);
         }
         case 'intN': return `s.loadIntBig(${ty.n})`;
         case 'uintN': return `s.loadUintBig(${ty.n})`;
@@ -43,46 +88,46 @@ function emitLoadExpr(ctx, fieldPath, ty) {
         case 'bitsN': return `${codegen_ctx_1.RUNTIME.loadTolkBitsN}(s, ${ty.n})`;
         case 'nullLiteral': return `null`;
         case 'void': return `void 0`;
-        case 'nullable': return `s.loadBoolean() ? ${emitLoadExpr(ctx, fieldPath, ty.inner)} : null`;
-        case 'cellOf': return `${codegen_ctx_1.RUNTIME.loadCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(s, ${emitLoadCallback(ctx, fieldPath, ty.inner)})`;
-        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.loadArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner)})`;
-        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.loadLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner)})`;
-        case 'tensor': return `[${ty.items.map((item, i) => emitLoadExpr(ctx, `${fieldPath}[${i}]`, item)).join(', ')}]`;
-        case 'shapedTuple': return `[${ty.items.map((item, i) => emitLoadExpr(ctx, `${fieldPath}[${i}]`, item)).join(', ')}]`;
-        case 'mapKV': return `c.Dictionary.load<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.k, ty.v)}>(${emitDictKVSerializers(ctx, fieldPath, ty.k, ty.v)}, s)`;
-        case 'EnumRef': return `${ty.enum_name}.fromSlice(s)`;
+        case 'nullable': return `s.loadBoolean() ? ${emitLoadExpr(ctx, fieldPath, ty.inner_ty_idx)} : null`;
+        case 'cellOf': return `${codegen_ctx_1.RUNTIME.loadCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(s, ${emitLoadCallback(ctx, fieldPath, ty.inner_ty_idx)})`;
+        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.loadArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner_ty_idx)})`;
+        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.loadLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(s, ${emitLoadCallback(ctx, fieldPath + '[ith]', ty.inner_ty_idx)})`;
+        case 'tensor': return `[${ty.items_ty_idx.map((ty_idx, i) => emitLoadExpr(ctx, `${fieldPath}[${i}]`, ty_idx)).join(', ')}]`;
+        case 'shapedTuple': return `[${ty.items_ty_idx.map((ty_idx, i) => emitLoadExpr(ctx, `${fieldPath}[${i}]`, ty_idx)).join(', ')}]`;
+        case 'mapKV': return `c.Dictionary.load<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.key_ty_idx, ty.value_ty_idx)}>(${emitDictKVSerializers(ctx, fieldPath, ty.key_ty_idx, ty.value_ty_idx)}, s)`;
+        case 'EnumRef': return `${(0, formatting_1.safeJsIdent)(ty.enum_name)}.fromSlice(s)`;
         case 'StructRef': {
-            if (ty.type_args) {
-                const cb = ty.type_args.map((ta) => emitLoadCallback(ctx, fieldPath, ta)).join(', ');
-                return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.fromSlice<${ty.type_args.map((ta) => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(s, ${cb})`;
+            if (ty.type_args_ty_idx) {
+                let innerLoad = emitLoadOfStruct(ctx, ctx.symbols.getStruct(ty.struct_name), tyIdx);
+                return `(() => {${formatting_1.OutBuf.onNewLine(innerLoad)}})()`;
             }
             return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.fromSlice(s)`;
         }
         case 'AliasRef': {
-            if (ty.type_args) {
-                const cb = ty.type_args.map((ta) => emitLoadCallback(ctx, fieldPath, ta)).join(', ');
-                return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.fromSlice<${ty.type_args.map((ta) => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(s, ${cb})`;
+            if (ty.type_args_ty_idx) {
+                let innerLoad = emitLoadOfAlias(ctx, ctx.symbols.getAlias(ty.alias_name), tyIdx);
+                return innerLoad.substring(7, innerLoad.length - 1); // `return {expr};`
             }
             return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.fromSlice(s)`;
         }
-        case 'genericT': return `loadFn_${ty.name_t}(s)`;
+        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} at ${fieldPath}`);
         case 'union': {
-            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
-            const isEither01 = variants.length === 2 && variants[0].prefix_str === '0b0' && variants[1].prefix_str === '0b1';
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants, uLabelTyIdx);
+            const isEither01 = variants.length === 2 && variants[0].prefix_num === 0 && variants[1].prefix_num === 1;
             if (isEither01) {
-                const l = (0, emit_ts_types_1.emitUnionLabelAndValue)(variants[0], emitLoadExpr(ctx, fieldPath, variants[0].variant_ty));
-                const r = (0, emit_ts_types_1.emitUnionLabelAndValue)(variants[1], emitLoadExpr(ctx, fieldPath, variants[1].variant_ty));
+                const l = (0, emit_ts_types_1.emitUnionLabelAndValue)(variants[0], emitLoadExpr(ctx, fieldPath, variants[0].variant_ty_idx));
+                const r = (0, emit_ts_types_1.emitUnionLabelAndValue)(variants[1], emitLoadExpr(ctx, fieldPath, variants[1].variant_ty_idx));
                 return `s.loadBoolean() ? ${r} : ${l}`;
             }
             let buf = new formatting_1.OutBuf();
             for (let v of variants) {
                 const checkFn = v.is_prefix_implicit ? codegen_ctx_1.RUNTIME.lookupPrefixAndEat : codegen_ctx_1.RUNTIME.lookupPrefix;
-                const body = (0, emit_ts_types_1.emitUnionLabelAndValue)(v, emitLoadExpr(ctx, fieldPath, v.variant_ty));
-                buf.push(`${checkFn}(s, ${v.prefix_str}, ${v.prefix_len}) ? ${body} :`);
+                const body = (0, emit_ts_types_1.emitUnionLabelAndValue)(v, emitLoadExpr(ctx, fieldPath, v.variant_ty_idx));
+                buf.push(`${checkFn}(s, ${(0, emit_ts_types_1.emitPrefixHex)(v)}, ${v.prefix_len}) ? ${body} :`);
                 if (v.is_prefix_implicit) {
                     ctx.has_implicitUnionPrefix = true;
                 }
-                if (v.prefix_str === variants[0].prefix_str) {
+                if (v.prefix_num === variants[0].prefix_num && v.prefix_len === variants[0].prefix_len) {
                     buf.indent();
                 }
             }
@@ -96,31 +141,62 @@ function emitLoadExpr(ctx, fieldPath, ty) {
 // e.g., `loadCellRef<T>(s, {callbackForT})`.
 // We could just emit `(s) => loadExprForT(s)`, but to produce less boilerplate, shorten common cases:
 // not `(s) => SomeStruct.fromSlice(s)` but `SomeStruct.fromSlice` as a valid callback.
-function emitLoadCallback(ctx, fieldPath, ty) {
+function emitLoadCallback(ctx, fieldPath, tyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     if (ty.kind === 'addressAny')
         return codegen_ctx_1.RUNTIME.loadTolkAddressAny;
     if (ty.kind === 'remaining')
         return codegen_ctx_1.RUNTIME.loadTolkRemaining;
     if (ty.kind === 'EnumRef')
-        return `${ty.enum_name}.fromSlice`;
-    if (ty.kind === 'genericT')
-        return `loadFn_${ty.name_t}`;
-    if (ty.kind === 'StructRef' && !ty.type_args)
+        return `${(0, formatting_1.safeJsIdent)(ty.enum_name)}.fromSlice`;
+    if (ty.kind === 'StructRef' && !ty.type_args_ty_idx)
         return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.fromSlice`;
-    if (ty.kind === 'AliasRef' && !ty.type_args)
+    if (ty.kind === 'AliasRef' && !ty.type_args_ty_idx)
         return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.fromSlice`;
-    return formatting_1.OutBuf.onNewLine(`(s) => ${emitLoadExpr(ctx, fieldPath, ty)}`);
+    return formatting_1.OutBuf.onNewLine(`(s) => ${emitLoadExpr(ctx, fieldPath, tyIdx)}`);
+}
+// Emit body of `SomeStruct.store` method.
+// Also called to store `Wrapper<int32>`, because `store` is not generated for generics, they are in-place (monomorphization).
+function emitStoreOfStruct(ctx, tsExpr, structRef, instantiationTyIdx) {
+    if (structRef.custom_pack_unpack?.pack_to_builder) {
+        return `invokeCustomPackToBuilder<${(0, formatting_1.safeJsIdent)(structRef.name)}>('${structRef.name}', self, b);`;
+    }
+    let buf = new formatting_1.OutBuf();
+    if (structRef.prefix) {
+        buf.push(`b.storeUint(${(0, emit_ts_types_1.emitPrefixHex)(structRef.prefix)}, ${structRef.prefix.prefix_len});`);
+    }
+    for (let f of ctx.symbols.structFieldsOf(instantiationTyIdx)) {
+        buf.push(emitStoreStatement(ctx, `${tsExpr}${(0, formatting_1.safeFieldRead)(f.name)}`, f.ty_idx, f.uLabelTyIdx));
+    }
+    return buf.toString();
+}
+// Emit body of `SomeAlias.store` method.
+// Also called to store `Either<int32, int64>`, because `store` is not generated for generics.
+function emitStoreOfAlias(ctx, tsExpr, aliasRef, instantiationTyIdx) {
+    if (aliasRef.custom_pack_unpack?.pack_to_builder) {
+        return `invokeCustomPackToBuilder<${(0, formatting_1.safeJsIdent)(aliasRef.name)}>('${aliasRef.name}', self, b);`;
+    }
+    let target = ctx.symbols.aliasTargetOf(instantiationTyIdx);
+    return emitStoreStatement(ctx, tsExpr, target.ty_idx, target.uLabelTyIdx);
+}
+// Emit body of `SomeEnum.store` method.
+function emitStoreOfEnum(ctx, tsExpr, enumRef) {
+    if (enumRef.custom_pack_unpack?.pack_to_builder) {
+        return `return invokeCustomPackToBuilder<${(0, formatting_1.safeJsIdent)(enumRef.name)}>('${enumRef.name}', self, b);`;
+    }
+    return emitStoreStatement(ctx, tsExpr, enumRef.encoded_as_ty_idx);
 }
 // Emit a TS "store {expr of type ty} into builder `b`" statement.
 // Parameter `tsExpr` is a valid expression: "self.field", "v" (inside a callback), and other.
-function emitStoreStatement(ctx, tsExpr, ty) {
+function emitStoreStatement(ctx, tsExpr, tyIdx, uLabelTyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'int':
         case 'unknown':
         case 'nullLiteral':
         case 'callable': {
             let hint = ty.kind === 'int' ? ' (not int32/uint64/etc.)' : '';
-            throw new unsupported_errors_1.CantGeneratePackUnpack(`'${tsExpr}' is '${(0, types_kernel_1.renderTy)(ty)}'${hint}`);
+            throw new unsupported_errors_1.CantGeneratePackUnpack(`'${tsExpr}' is '${(0, types_kernel_1.renderTy)(ctx.symbols, tyIdx)}'${hint}`);
         }
         case 'intN': return `b.storeInt(${tsExpr}, ${ty.n});`;
         case 'uintN': return `b.storeUint(${tsExpr}, ${ty.n});`;
@@ -139,49 +215,48 @@ function emitStoreStatement(ctx, tsExpr, ty) {
         case 'addressAny': return `${codegen_ctx_1.RUNTIME.storeTolkAddressAny}(${tsExpr}, b);`;
         case 'bitsN': return `${codegen_ctx_1.RUNTIME.storeTolkBitsN}(${tsExpr}, ${ty.n}, b);`;
         case 'void': return ``;
-        case 'nullable': return `${codegen_ctx_1.RUNTIME.storeTolkNullable}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner)});`;
-        case 'cellOf': return `${codegen_ctx_1.RUNTIME.storeCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner)});`;
-        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.storeArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner)});`;
-        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.storeLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner)});`;
-        case 'tensor': return ty.items.length ? ty.items.map((_, i) => emitStoreStatement(ctx, `${tsExpr}[${i}]`, ty.items[i])).join('\n') : `{}`;
-        case 'shapedTuple': return ty.items.length ? ty.items.map((_, i) => emitStoreStatement(ctx, `${tsExpr}[${i}]`, ty.items[i])).join('\n') : `{}`;
-        case 'mapKV': return `b.storeDict<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.k, ty.v)}>(${tsExpr}, ${emitDictKVSerializers(ctx, tsExpr, ty.k, ty.v)});`;
-        case 'EnumRef': return `${ty.enum_name}.store(${tsExpr}, b);`;
+        case 'nullable': return `${codegen_ctx_1.RUNTIME.storeTolkNullable}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
+        case 'cellOf': return `${codegen_ctx_1.RUNTIME.storeCellRef}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
+        case 'arrayOf': return `${codegen_ctx_1.RUNTIME.storeArrayOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
+        case 'lispListOf': return `${codegen_ctx_1.RUNTIME.storeLispListOf}<${(0, emit_ts_types_1.emitTsType)(ctx, ty.inner_ty_idx)}>(${tsExpr}, b, ${emitStoreCallback(ctx, ty.inner_ty_idx)});`;
+        case 'tensor': return ty.items_ty_idx.length ? ty.items_ty_idx.map((ty_idx, i) => emitStoreStatement(ctx, `${tsExpr}[${i}]`, ty_idx)).join('\n') : `{}`;
+        case 'shapedTuple': return ty.items_ty_idx.length ? ty.items_ty_idx.map((ty_idx, i) => emitStoreStatement(ctx, `${tsExpr}[${i}]`, ty_idx)).join('\n') : `{}`;
+        case 'mapKV': return `b.storeDict<${(0, emit_ts_types_1.emitDictKVTypeArgs)(ctx, ty.key_ty_idx, ty.value_ty_idx)}>(${tsExpr}, ${emitDictKVSerializers(ctx, tsExpr, ty.key_ty_idx, ty.value_ty_idx)});`;
+        case 'EnumRef': return `${(0, formatting_1.safeJsIdent)(ty.enum_name)}.store(${tsExpr}, b);`;
         case 'StructRef': {
-            if (ty.type_args) {
-                const cb = ty.type_args.map(ta => emitStoreCallback(ctx, ta)).join(', ');
-                return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.store<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${tsExpr}, b, ${cb});`;
+            if (ty.type_args_ty_idx) {
+                return emitStoreOfStruct(ctx, tsExpr, ctx.symbols.getStruct(ty.struct_name), tyIdx);
             }
             return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.store(${tsExpr}, b);`;
         }
         case 'AliasRef': {
-            if (ty.type_args) {
-                const cb = ty.type_args.map(ta => emitStoreCallback(ctx, ta)).join(', ');
-                return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.store<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${tsExpr}, b, ${cb});`;
+            if (ty.type_args_ty_idx) {
+                return emitStoreOfAlias(ctx, tsExpr, ctx.symbols.getAlias(ty.alias_name), tyIdx);
             }
             return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.store(${tsExpr}, b);`;
         }
-        case 'genericT': return `storeFn_${ty.name_t}(${tsExpr}, b);`;
+        case 'genericT': throw new Error(`unexpected genericT=${ty.name_t} at ${tsExpr}`);
         case 'union': {
             const buf = new formatting_1.OutBuf();
-            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants);
-            const hasNull = variants.find(v => v.variant_ty.kind === 'nullLiteral');
+            const variants = (0, types_kernel_1.createLabelsForUnion)(ctx.symbols, ty.variants, uLabelTyIdx);
+            const hasNull = variants.find(v => ctx.symbols.tyByIdx(v.variant_ty_idx).kind === 'nullLiteral');
             if (hasNull) {
                 buf.push(`if (${tsExpr} === null) {`);
-                buf.push(`b.storeUint(${hasNull.prefix_str}, ${hasNull.prefix_len});`);
+                buf.push(`b.storeUint(${(0, emit_ts_types_1.emitPrefixHex)(hasNull)}, ${hasNull.prefix_len});`);
                 buf.push(`} else switch (${tsExpr}.$) {`);
             }
             else {
                 buf.push(`switch (${tsExpr}.$) {`);
             }
-            for (let v of variants) {
-                if (v.variant_ty.kind === 'nullLiteral')
+            for (let i = 0; i < variants.length; ++i) {
+                const v = variants[i];
+                if (ctx.symbols.tyByIdx(v.variant_ty_idx).kind === 'nullLiteral')
                     continue;
                 buf.push(`case '${v.labelStr}':`).indent();
                 if (v.is_prefix_implicit) {
-                    buf.push(`b.storeUint(${v.prefix_str}, ${v.prefix_len});`);
+                    buf.push(`b.storeUint(${(0, emit_ts_types_1.emitPrefixHex)(v)}, ${v.prefix_len});`);
                 }
-                buf.push(emitStoreStatement(ctx, v.hasValueField ? `${tsExpr}.value` : tsExpr, v.variant_ty));
+                buf.push(emitStoreStatement(ctx, v.hasValueField ? `${tsExpr}.value` : tsExpr, v.variant_ty_idx));
                 buf.push('break;').outdent();
             }
             buf.push('}');
@@ -192,22 +267,21 @@ function emitStoreStatement(ctx, tsExpr, ty) {
 // Emit a TS "store {expr of type ty} into builder `b`" callback (not expression).
 // Callbacks are passed for generics (user-defined generic types and built-ins),
 // e.g., `storeTolkNullable<T>(s, {callbackForT})`.
-function emitStoreCallback(ctx, ty) {
+function emitStoreCallback(ctx, tyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     if (ty.kind === 'addressAny')
         return codegen_ctx_1.RUNTIME.storeTolkAddressAny;
     if (ty.kind === 'remaining')
         return codegen_ctx_1.RUNTIME.storeTolkRemaining;
     if (ty.kind === 'EnumRef')
-        return `${ty.enum_name}.store`;
-    if (ty.kind === 'genericT')
-        return `storeFn_${ty.name_t}`;
-    if (ty.kind === 'StructRef' && !ty.type_args)
+        return `${(0, formatting_1.safeJsIdent)(ty.enum_name)}.store`;
+    if (ty.kind === 'StructRef' && !ty.type_args_ty_idx)
         return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.store`;
-    if (ty.kind === 'AliasRef' && !ty.type_args)
+    if (ty.kind === 'AliasRef' && !ty.type_args_ty_idx)
         return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.store`;
     // for simple statements, drop trailing `;` and use it as an expression:
     // not `(v,b) => { b.storeInt(v, 8); }` but `(v,b) => b.storeInt(v, 8)`
-    let stmt = emitStoreStatement(ctx, 'v', ty);
+    let stmt = emitStoreStatement(ctx, 'v', tyIdx);
     if (stmt.indexOf(';') !== stmt.length - 1 || stmt.includes('\n') || stmt.includes('{')) {
         stmt = '{ ' + stmt + ' }';
     }
@@ -219,43 +293,43 @@ function emitStoreCallback(ctx, ty) {
 // Emit a TS "make a cell from {expr}" expression.
 // It's essentially beginCell + call storing callback + endCell.
 // Parameter `tsExpr` is a valid expression: "self.field", "v" (inside a callback), and other.
-function emitMakeCellFromExpr(ctx, tsExpr, ty, disableShortHand = false) {
+function emitMakeCellFromExpr(ctx, tsExpr, tyIdx, disableShortHand = false) {
     if (disableShortHand) {
-        return `${codegen_ctx_1.RUNTIME.makeCellFrom}<${(0, emit_ts_types_1.emitTsType)(ctx, ty)}>(${tsExpr}, ${emitStoreCallback(ctx, ty)})`;
+        return `${codegen_ctx_1.RUNTIME.makeCellFrom}<${(0, emit_ts_types_1.emitTsType)(ctx, tyIdx)}>(${tsExpr}, ${emitStoreCallback(ctx, tyIdx)})`;
     }
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     switch (ty.kind) {
         case 'EnumRef': {
             return `${(0, formatting_1.safeJsIdent)(ty.enum_name)}.toCell(${tsExpr})`;
         }
         case 'StructRef': {
-            if (ty.type_args) {
-                const cb = ty.type_args.map(ta => emitStoreCallback(ctx, ta)).join(', ');
-                return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.toCell<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${tsExpr}, ${cb})`;
+            if (ty.type_args_ty_idx) {
+                return emitMakeCellFromExpr(ctx, tsExpr, tyIdx, true);
             }
             return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.toCell(${tsExpr})`;
         }
         case 'AliasRef': {
-            if (ty.type_args) {
-                const cb = ty.type_args.map(ta => emitStoreCallback(ctx, ta)).join(', ');
-                return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.toCell<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${tsExpr}, ${cb})`;
+            if (ty.type_args_ty_idx) {
+                return emitMakeCellFromExpr(ctx, tsExpr, tyIdx, true);
             }
             return `${(0, formatting_1.safeJsIdent)(ty.alias_name)}.toCell(${tsExpr})`;
         }
         default:
-            return emitMakeCellFromExpr(ctx, tsExpr, ty, true);
+            return emitMakeCellFromExpr(ctx, tsExpr, tyIdx, true);
     }
 }
 // Emit a TS "StructName.create({bodyArg})" expression.
 // For instance, sendXXX and fromStorage methods accept struct fields and call create()
 // in order to enrich passed fields with `$` tag and default values.
-function emitCallToCreateMethodExpr(ctx, bodyArg, ty) {
+function emitCallToCreateMethodExpr(ctx, bodyArg, tyIdx) {
+    const ty = ctx.symbols.tyByIdx(tyIdx);
     if (ty.kind === 'StructRef') {
-        let structRef = ctx.symbols.getStruct(ty.struct_name);
-        if (structRef.fields.length === 0) {
+        let fields = ctx.symbols.structFieldsOf(tyIdx);
+        if (fields.length === 0) {
             bodyArg = ''; // create() is without arguments, body is an empty object
         }
-        if (ty.type_args) {
-            return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.create<${ty.type_args.map(ta => (0, emit_ts_types_1.emitTsType)(ctx, ta)).join(', ')}>(${bodyArg})`;
+        if (ty.type_args_ty_idx) {
+            return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.create<${ty.type_args_ty_idx.map(ty_idx => (0, emit_ts_types_1.emitTsType)(ctx, ty_idx)).join(', ')}>(${bodyArg})`;
         }
         return `${(0, formatting_1.safeJsIdent)(ty.struct_name)}.create(${bodyArg})`;
     }
@@ -264,19 +338,21 @@ function emitCallToCreateMethodExpr(ctx, bodyArg, ty) {
 // Emit a key (de)serializer for c.Dictionary<K, V>.
 // Only a strict subset of KeyT is allowed by the @ton/core library.
 // For others, we can not generate wrappers at all (not only to/from cell, but even declarations).
-function emitDictKeySerializer(ctx, fieldPath, tyK) {
+function emitDictKeySerializer(ctx, fieldPath, tyKIdx) {
+    const tyK = ctx.symbols.tyByIdx(tyKIdx);
     if (tyK.kind === 'intN')
         return `c.Dictionary.Keys.BigInt(${tyK.n})`;
     if (tyK.kind === 'uintN')
         return `c.Dictionary.Keys.BigUint(${tyK.n})`;
     if (tyK.kind === 'address')
         return `c.Dictionary.Keys.Address()`;
-    throw new unsupported_errors_1.NonStandardDictKey(`'${fieldPath}' is 'map<${(0, types_kernel_1.renderTy)(tyK)}, ...>': such a non-standard map key can not be handled by @ton/core library`);
+    throw new unsupported_errors_1.NonStandardDictKey(`'${fieldPath}' is 'map<${(0, types_kernel_1.renderTy)(ctx.symbols, tyKIdx)}, ...>': such a non-standard map key can not be handled by @ton/core library`);
 }
 // Emit a value (de)serializer for c.Dictionary<K, V>.
 // Unlike keys, @ton/core allows arbitrary values (passing custom (de)serializers).
 // For common cases, use a built-in one; for others, create a custom.
-function emitDictValueSerializer(ctx, fieldPath, tyV) {
+function emitDictValueSerializer(ctx, fieldPath, tyVIdx) {
+    const tyV = ctx.symbols.tyByIdx(tyVIdx);
     if (tyV.kind === 'intN')
         return `c.Dictionary.Values.BigInt(${tyV.n})`;
     if (tyV.kind === 'uintN')
@@ -288,9 +364,9 @@ function emitDictValueSerializer(ctx, fieldPath, tyV) {
     if (tyV.kind === 'cell')
         return `c.Dictionary.Values.Cell()`;
     ctx.has_customDictV = true;
-    return `${codegen_ctx_1.RUNTIME.createDictionaryValue}<${(0, emit_ts_types_1.emitTsType)(ctx, tyV)}>(${emitLoadCallback(ctx, fieldPath, tyV)}, ${emitStoreCallback(ctx, tyV)})`;
+    return `${codegen_ctx_1.RUNTIME.createDictionaryValue}<${(0, emit_ts_types_1.emitTsType)(ctx, tyVIdx)}>(${emitLoadCallback(ctx, fieldPath, tyVIdx)}, ${emitStoreCallback(ctx, tyVIdx)})`;
 }
 // Emit (de)serializers for c.Dictionary<K, V> (two arguments separated by a comma).
-function emitDictKVSerializers(ctx, fieldPath, tyK, tyV) {
-    return emitDictKeySerializer(ctx, fieldPath, tyK) + ', ' + emitDictValueSerializer(ctx, fieldPath, tyV);
+function emitDictKVSerializers(ctx, fieldPath, tyKIdx, tyVIdx) {
+    return emitDictKeySerializer(ctx, fieldPath, tyKIdx) + ', ' + emitDictValueSerializer(ctx, fieldPath, tyVIdx);
 }

package/dist/emit-stack-rw.d.ts

@@ -1,4 +1,3 @@
-import type { Ty } from './abi-types';
 import { CodegenCtx } from './codegen-ctx';
-export declare function emitStackReadExpr(ctx: CodegenCtx, fieldPath: string, ty: Ty, unTupleIfW?: boolean): string;
-export declare function emitStackWriteItems(ctx: CodegenCtx, tsExpr: string, ty: Ty, tupleIfW?: boolean): string[];
+export declare function emitStackReadExpr(ctx: CodegenCtx, fieldPath: string, tyIdx: number, unTupleIfW?: boolean, uLabelTyIdx?: number): string;
+export declare function emitStackWriteItems(ctx: CodegenCtx, tsExpr: string, tyIdx: number, tupleIfW?: boolean, uLabelTyIdx?: number): string[];