gen-typescript-from-tolk-dev 0.1.0

package/src/dynamic-serialization.ts

@@ -0,0 +1,430 @@
+import * as c from '@ton/core';          // todo is it peer dependency?
+import type { Ty } from './abi-types';
+import { CantPackDynamic, CantUnpackDynamic, InvalidDynamicInput, NonStandardDictKey } from './unsupported-errors';
+import { DynamicCtx } from './dynamic-ctx';
+import {
+    checkIsArray,
+    checkIsBoolean,
+    checkIsNumber,
+    checkIsObject,
+    checkIsObjectWithProperty,
+    checkIsString,
+    throwInvalidInput,
+} from './dynamic-validation';
+import { createLabelsForUnion, instantiateGenerics, renderTy } from './types-kernel'
+
+/*
+    Dynamic serialization works without generating TypeScript wrappers.
+    Just given an ABI, serialize any JS input to a cell, and unpack back.
+    Its purpose is orthogonal to wrappers:
+    - wrappers — for manual development
+                 (write tests, deployment, and other manual interactions with your contract)
+    - dynamic serialization — for tolk-js, explorers, etc. 
+                 (pass some data from auto-generated UI to some contract just given its ABI)
+ */
+
+
+function lookupPrefix(s: c.Slice, expected: number, prefixLen: number): boolean {
+    return s.remainingBits >= prefixLen && s.preloadUint(prefixLen) === expected;
+}
+
+export function createTonCoreDictionaryKey(fieldPath: string, tyK: Ty): c.DictionaryKey<any> {
+    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 NonStandardDictKey(`'${fieldPath}' is 'map<${renderTy(tyK)}, ...>': such a non-standard map key can not be handled by @ton/core library`);
+}
+
+export function createTonCoreDictionaryValue(ctx: DynamicCtx, fieldPath: string, tyV: Ty): c.DictionaryValue<any> {
+    return {
+        serialize(self: any, b: c.Builder) {
+            dynamicPack(ctx, fieldPath, tyV, self, b);
+        },
+        parse(s: c.Slice): any {
+            return dynamicUnpack(ctx, fieldPath, tyV, s);
+        }
+    }
+}
+
+// Parameter `fieldPath` is used for error messages only, e.g. when provided invalid input.
+export function dynamicPack(ctx: DynamicCtx, fieldPath: string, ty: Ty, v: any, b: c.Builder): void {
+    switch (ty.kind) {
+        case 'intN': {
+            checkIsNumber(fieldPath, ty, v);
+            b.storeInt(v, ty.n);
+            break;
+        }
+        case 'uintN': {
+            checkIsNumber(fieldPath, ty, v);
+            b.storeUint(v, ty.n);
+            break;
+        }
+        case 'varintN': {
+            checkIsNumber(fieldPath, ty, v);
+            b.storeVarInt(v, Math.log2(ty.n));
+            break;
+        }
+        case 'varuintN': {
+            checkIsNumber(fieldPath, ty, v);
+            b.storeVarUint(v, Math.log2(ty.n));
+            break;
+        }
+        case 'coins': {
+            checkIsNumber(fieldPath, ty, v);
+            b.storeCoins(v);
+            break;
+        }
+        case 'bool': {
+            checkIsBoolean(fieldPath, ty, v);
+            b.storeBit(v);
+            break;
+        }
+        case 'cell': {
+            checkIsObject(fieldPath, ty, v);
+            b.storeRef(v);
+            break;
+        }
+        case 'builder': {
+            checkIsObject(fieldPath, ty, v);
+            b.storeBuilder(v);
+            break;
+        }
+        case 'slice': {
+            checkIsObject(fieldPath, ty, v);
+            b.storeSlice(v);
+            break;
+        }
+        case 'string': {
+            checkIsString(fieldPath, ty, v);
+            b.storeStringRefTail(v);
+            break;
+        }
+        case 'remaining': {
+            checkIsObject(fieldPath, ty, v);
+            b.storeSlice(v);
+            break;
+        }
+        case 'address': {
+            checkIsObject(fieldPath, ty, v);
+            b.storeAddress(v);
+            break;
+        }
+        case 'addressOpt': {
+            checkIsObject(fieldPath, ty, v, true);
+            b.storeAddress(v);
+            break;
+        }
+        case 'addressExt': {
+            checkIsObject(fieldPath, ty, v);
+            b.storeAddress(v);
+            break;
+        }
+        case 'addressAny': {
+            if (v === 'none') {
+                b.storeAddress(null);
+            } else {
+                checkIsObject(fieldPath, ty, v);
+                b.storeAddress(v);
+            }
+            break;
+        }
+        case 'bitsN': {
+            checkIsObject(fieldPath, ty, v);
+            if (v.remainingBits !== ty.n || v.remainingRefs !== 0) {
+                throwInvalidInput(fieldPath, ty, `expected ${ty.n} bits and 0 refs, got ${v.remainingBits} bits and ${v.remainingRefs} refs`);
+            }
+            b.storeSlice(v);
+            break;
+        }
+        case 'nullable': {
+            if (v === null) {
+                b.storeUint(0, 1);
+            } else {
+                b.storeUint(1, 1);
+                dynamicPack(ctx, fieldPath, ty.inner, v, b);
+            }
+            break;
+        }
+        case 'cellOf': {
+            checkIsObjectWithProperty(fieldPath, ty, v, 'ref');
+            let b_ref = c.beginCell();
+            dynamicPack(ctx, fieldPath, ty.inner, v.ref, b_ref);
+            b.storeRef(b_ref.endCell());
+            break;
+        }
+        case 'arrayOf': {
+            checkIsArray(fieldPath, ty, v);
+            // the compiler stores array<T> in chunks; in TypeScript, for simplicity, store "1 elem = 1 ref"
+            let tail = null as c.Cell | null;
+            for (let i = 0; i < v.length; ++i) {
+                let chunkB = c.beginCell().storeMaybeRef(tail);
+                dynamicPack(ctx, fieldPath + '[ith]', ty.inner, v[v.length - 1 - i], chunkB);
+                tail = chunkB.endCell();
+            }
+            b.storeUint(v.length, 8);
+            b.storeMaybeRef(tail);
+            break;
+        }
+        case 'lispListOf': {
+            checkIsArray(fieldPath, ty, v);
+            let tail = c.Cell.EMPTY;
+            for (let i = 0; i < v.length; ++i) {
+                let itemB = c.beginCell();
+                dynamicPack(ctx, `${fieldPath}[${i}]`, ty.inner, v[i], itemB);
+                tail = itemB.storeRef(tail).endCell();
+            }
+            b.storeRef(tail);
+            break;
+        }
+        case 'tensor':             // `(T1, T2)` and `[T1, T2]` are both TypeScript arrays
+        case 'shapedTuple': {      // (but in Tolk, they are different: a tensor and a TVM shaped tuple)
+            checkIsArray(fieldPath, ty, v, ty.items.length);
+            for (let i = 0; i < v.length; ++i) {
+                dynamicPack(ctx, `${fieldPath}[${i}]`, ty.items[i], v[i], b);
+            }
+            break;
+        }
+        case 'mapKV': {
+            checkIsObject(fieldPath, ty, v);
+            let dictKey = createTonCoreDictionaryKey(fieldPath, ty.k);
+            let dictValue = createTonCoreDictionaryValue(ctx, fieldPath, ty.v);
+            b.storeDict(v, dictKey, dictValue);
+            break;
+        }
+        case 'EnumRef': {
+            checkIsNumber(fieldPath, ty, v);
+            let enumRef = ctx.symbols.getEnum(ty.enumName);
+            if (enumRef.customPackUnpack?.packToBuilder) {
+                ctx.getCustomPackFnOrThrow(ty.enumName, fieldPath)(v, b);
+                break;
+            }
+            dynamicPack(ctx, fieldPath, enumRef.encodedAs, v, b);
+            break;
+        }
+        case 'StructRef': {
+            checkIsObject(fieldPath, ty, v);
+            let structRef = ctx.symbols.getStruct(ty.structName);
+            if (structRef.customPackUnpack?.packToBuilder) {
+                ctx.getCustomPackFnOrThrow(ty.structName, fieldPath)(v, b);
+                break;
+            }
+            if (structRef.prefix) {
+                b.storeUint(+structRef.prefix.prefixStr, structRef.prefix.prefixLen);
+            }
+            for (let f of structRef.fields) {
+                const fTy = ty.typeArgs ? instantiateGenerics(f.ty, structRef.typeParams, ty.typeArgs) : f.ty;
+                try {
+                    dynamicPack(ctx, `${fieldPath}.${f.name}`, fTy, v[f.name], b);
+                } catch (ex: any) {
+                    if (ex instanceof InvalidDynamicInput) {
+                        throw ex;
+                    }
+                    // serialization errors from @ton/core, like "value is out of range"
+                    throwInvalidInput(`${fieldPath}.${f.name}`, fTy, ex.message ?? ex.toString());
+                }
+            }
+            break;
+        }
+        case 'AliasRef': {
+            let aliasRef = ctx.symbols.getAlias(ty.aliasName);
+            if (aliasRef.customPackUnpack?.packToBuilder) {
+                ctx.getCustomPackFnOrThrow(ty.aliasName, fieldPath)(v, b);
+                break;
+            }
+            const targetTy = ty.typeArgs ? instantiateGenerics(aliasRef.targetTy, aliasRef.typeParams, ty.typeArgs) : aliasRef.targetTy;
+            dynamicPack(ctx, fieldPath, targetTy, v, b);
+            break;
+        }
+        case 'union': {
+            const variants = createLabelsForUnion(ctx.symbols, ty.variants);
+            const hasNull = variants.find(v => v.variantTy.kind === 'nullLiteral');
+            if (hasNull && v === null) {
+                b.storeUint(+hasNull.prefixStr, hasNull.prefixLen);
+            } else {
+                checkIsObjectWithProperty(fieldPath, ty, v, '$');
+
+                const activeVariant = variants.find(variant => v.$ === variant.labelStr); 
+                if (!activeVariant) {
+                    throwInvalidInput(fieldPath, ty, `non-existing union variant for $ = '${v.$}'`);
+                }
+                if (activeVariant.hasValueField && !v.hasOwnProperty('value')) {
+                    throwInvalidInput(fieldPath, ty, `expected {$,value} but field 'value' not provided`);
+                }
+                if (activeVariant.isPrefixImplicit) {
+                    b.storeUint(+activeVariant.prefixStr, activeVariant.prefixLen);
+                }
+                let actualValue = activeVariant.hasValueField ? v.value : v;
+                dynamicPack(ctx, `${fieldPath}#${activeVariant.labelStr}`, activeVariant.variantTy, actualValue, b);
+            }
+            break;
+        }
+        case 'void':
+            break;
+
+        default:
+            throw new CantPackDynamic(fieldPath, `type '${renderTy(ty)}' is not serializable`);
+    }
+}
+
+// Parameter `fieldPath` is used for error messages only, e.g. when can't deserialize exact field (bad slice).
+export function dynamicUnpack(ctx: DynamicCtx, fieldPath: string, ty: Ty, s: c.Slice): any {
+    switch (ty.kind) {
+        case 'intN':        return s.loadIntBig(ty.n);
+        case 'uintN':       return s.loadUintBig(ty.n);
+        case 'varintN':     return s.loadVarIntBig(Math.log2(ty.n));
+        case 'varuintN':    return s.loadVarUintBig(Math.log2(ty.n));
+        case 'coins':       return s.loadCoins();
+        case 'bool':        return s.loadBoolean();
+        case 'cell':        return s.loadRef();
+        case 'string':      return s.loadStringRefTail();
+        case 'remaining': {
+            let rest = s.clone();
+            s.loadBits(s.remainingBits);
+            while (s.remainingRefs) {
+                s.loadRef();
+            }
+            return rest;
+        }
+        case 'address':     return s.loadAddress();
+        case 'addressOpt':  return s.loadMaybeAddress();
+        case 'addressExt':  return s.loadExternalAddress();
+        case 'addressAny': {
+            let maybe_addr = s.loadAddressAny();
+            return maybe_addr === null ? 'none' : maybe_addr;
+        }
+        case 'bitsN':       return new c.Slice(new c.BitReader(s.loadBits(ty.n)), []);
+        case 'nullLiteral': return null;
+        case 'nullable':    return s.loadBoolean() ? dynamicUnpack(ctx, fieldPath, ty.inner, s) : null;
+        case 'cellOf': {
+            let s_ref = s.loadRef().beginParse();
+            return { ref: dynamicUnpack(ctx, fieldPath, ty.inner, s_ref) };
+        }
+        case 'arrayOf': {
+            let len = s.loadUint(8);
+            let head = s.loadMaybeRef();
+            let outArr = [];
+            while (head != null) {
+                let s = head.beginParse();
+                head = s.loadMaybeRef();
+                while (s.remainingBits || s.remainingRefs) {
+                    outArr.push(dynamicUnpack(ctx, fieldPath + '[ith]', ty.inner, s));
+                }
+            }
+            if (len !== outArr.length) {
+                throw new CantUnpackDynamic(fieldPath, `mismatch array binary data: expected ${len} elements, got ${outArr.length}`);
+            }
+            return outArr;
+        }
+        case 'lispListOf': {
+            let outArr = [];
+            let head = s.loadRef().beginParse();
+            while (head.remainingRefs) {
+                let tailSnaked = head.loadRef();
+                let headValue = dynamicUnpack(ctx, fieldPath + '[ith]', ty.inner, head);
+                head.endParse();    // ensure no data is present besides T
+                outArr.unshift(headValue);
+                head = tailSnaked.beginParse();
+            }
+            return outArr;
+        }
+        case 'tensor':
+        case 'shapedTuple': {
+            return ty.items.map((item, idx) => 
+                dynamicUnpack(ctx, `${fieldPath}[${idx}]`, item, s)
+            );
+        }
+        case 'mapKV': {
+            let dictKey = createTonCoreDictionaryKey(fieldPath, ty.k);
+            let dictValue = createTonCoreDictionaryValue(ctx, fieldPath, ty.v);
+            return s.loadDict(dictKey, dictValue);
+        }
+        case 'EnumRef': {
+            let enumRef = ctx.symbols.getEnum(ty.enumName);
+            if (enumRef.customPackUnpack?.unpackFromSlice) {
+                return ctx.getCustomUnpackFnOrThrow(ty.enumName, fieldPath)(s);
+            }
+            return dynamicUnpack(ctx, fieldPath, enumRef.encodedAs, s);
+        }
+        case 'StructRef': {
+            let structRef = ctx.symbols.getStruct(ty.structName);
+            if (structRef.customPackUnpack?.unpackFromSlice) {
+                return ctx.getCustomUnpackFnOrThrow(ty.structName, fieldPath)(s);
+            }
+            let result = { $: ty.structName } as Record<string, any>;
+            if (structRef.prefix) {
+                let prefix = s.loadUint(structRef.prefix.prefixLen);
+                if (prefix !== +structRef.prefix.prefixStr) {
+                    throw new CantUnpackDynamic(fieldPath, `incorrect prefix for '${ty.structName}', expected ${structRef.prefix.prefixStr}`);
+                }
+            }
+            for (let f of structRef.fields) {
+                const fTy = ty.typeArgs ? instantiateGenerics(f.ty, structRef.typeParams, ty.typeArgs) : f.ty;
+                try {
+                    result[f.name] = dynamicUnpack(ctx, `${fieldPath}.${f.name}`, fTy, s);
+                } catch (ex: any) {
+                    if (ex instanceof CantUnpackDynamic) {
+                        throw ex;
+                    }
+                    // deserialization errors due to invalid slice, show field name
+                    throw new CantUnpackDynamic(`${fieldPath}.${f.name}`, ex.message ?? ex.toString());
+                }
+            }
+            return result;
+        }
+        case 'AliasRef': {
+            let aliasRef = ctx.symbols.getAlias(ty.aliasName);
+            if (aliasRef.customPackUnpack?.unpackFromSlice) {
+                return ctx.getCustomUnpackFnOrThrow(ty.aliasName, fieldPath)(s);
+            }
+            const targetTy = ty.typeArgs ? instantiateGenerics(aliasRef.targetTy, aliasRef.typeParams, ty.typeArgs) : aliasRef.targetTy;
+            return dynamicUnpack(ctx, fieldPath, targetTy, s);
+        }
+        case 'genericT': throw new CantUnpackDynamic(fieldPath, 'unexpected genericT');
+        case 'union': {
+            for (const variant of createLabelsForUnion(ctx.symbols, ty.variants)) {
+                if (!lookupPrefix(s, +variant.prefixStr, variant.prefixLen)) {
+                    continue;
+                }
+                if (variant.isPrefixImplicit) {
+                    s.skip(variant.prefixLen);
+                }
+
+                let actualValue = dynamicUnpack(ctx, `${fieldPath}#${variant.labelStr}`, variant.variantTy, s);
+                if (!variant.hasValueField) {
+                    return actualValue;
+                }
+                return { $: variant.labelStr, value: actualValue };
+            }
+            throw new CantUnpackDynamic(fieldPath, 'none of union prefixes match');
+        }
+        case 'void':
+            return void 0;
+
+        default:
+            throw new CantUnpackDynamic(fieldPath, `type '${renderTy(ty)}' is not serializable`);
+    }
+}
+
+/**
+ * Pack any input to a builder according to an ABI schema.
+ * Example: `struct Point { x: int8, y: int8 }`.
+ * After being converted, it's stored as ABI.
+ * Call: `packToBuilderDynamic(ctx, structTy, { x: 10, y: 20 }, b)` appends 0x0A14.
+ * When input is incorrect (e.g. missing property in a JS object), throws InvalidDynamicInput.
+ */
+export function packToBuilderDynamic(ctx: DynamicCtx, ty: Ty, value: any, b: c.Builder): void {
+    let fieldPath = ty.kind === 'StructRef' ? ty.structName : 'self';
+    dynamicPack(ctx, fieldPath, ty, value, b);
+}
+
+/**
+ * Unpack any slice to a JS variable according to an ABI schema.
+ * Example: `struct Point { x: int8, y: int8 }`.
+ * Call: `unpackFromSliceDynamic(ctx, structTy, hex"0A14")` returns `{ x: 10, y: 20 }`.
+ * When ty can't be deserialized, throws CantUnpackDynamic.
+ */
+export function unpackFromSliceDynamic(ctx: DynamicCtx, ty: Ty, s: c.Slice): any {
+    let fieldPath = ty.kind === 'StructRef' ? ty.structName : 'self';
+    return dynamicUnpack(ctx, fieldPath, ty, s);
+}

package/src/dynamic-validation.ts

@@ -0,0 +1,55 @@
+import type { Ty } from './abi-types'
+import { InvalidDynamicInput } from './unsupported-errors'
+import { renderTy } from './types-kernel'
+
+export function throwInvalidInput(fieldPath: string, expectedTy: Ty, msgWhyInvalid: string): never {
+    throw new InvalidDynamicInput(`invalid value passed for '${fieldPath}' of type '${renderTy(expectedTy)}': ${msgWhyInvalid}`);
+}
+
+export function checkIsNumber(fieldPath: string, expectedTy: Ty, passedV: any): void {
+    let isNumber = typeof passedV === 'bigint' || typeof passedV === 'number';
+    if (!isNumber) {
+        throwInvalidInput(fieldPath, expectedTy, 'not a number');
+    }
+}
+
+export function checkIsBoolean(fieldPath: string, expectedTy: Ty, passedV: any): void {
+    let isBoolean = typeof passedV === 'boolean';
+    if (!isBoolean) {
+        throwInvalidInput(fieldPath, expectedTy, 'not a boolean');
+    }
+}
+
+export function checkIsString(fieldPath: string, expectedTy: Ty, passedV: any): void {
+    let isString = typeof passedV === 'string';
+    if (!isString) {
+        throwInvalidInput(fieldPath, expectedTy, 'not a string');
+    }
+}
+
+export function checkIsArray(fieldPath: string, expectedTy: Ty, passedV: any, expectedLen?: number): void {
+    let isArray = Array.isArray(passedV);
+    if (!isArray) {
+        throwInvalidInput(fieldPath, expectedTy, 'not an array');
+    }
+    if (expectedLen !== undefined && passedV.length !== expectedLen) {
+        throwInvalidInput(fieldPath, expectedTy, `expected ${expectedLen} elements, got ${passedV.length}`);
+    }
+}
+
+export function checkIsObject(fieldPath: string, expectedTy: Ty, passedV: any, allowNull = false): void {
+    let isObject = typeof passedV === 'object' && !Array.isArray(passedV);
+    if (passedV === null && !allowNull) {
+        isObject = false;
+    }
+    if (!isObject) {
+        throwInvalidInput(fieldPath, expectedTy, 'not an object');
+    }
+}
+
+export function checkIsObjectWithProperty(fieldPath: string, expectedTy: Ty, passedV: any, propertyName: string): void {
+    let isObject = typeof passedV === 'object' && !Array.isArray(passedV) && passedV !== null;
+    if (!isObject || !passedV.hasOwnProperty(propertyName)) {
+        throwInvalidInput(fieldPath, expectedTy, `not an object with property ${propertyName}`);
+    }
+}

package/src/emit-field-defs.ts

@@ -0,0 +1,60 @@
+import { ABIConstExpression, Ty } from './abi-types'
+import { CodegenCtx } from './codegen-ctx'
+import { safeFieldDecl } from './formatting'
+import { renderTy } from './types-kernel'
+
+// Default values of struct fields are also exported to TypeScript unless they are hard to be represented.
+// In practice, all simple values are okay: `f: int = 5`, `f: coins = ton("1")`, etc.
+// But in theory, a field can be a union, for example. It will require a large amount of work to support
+// cases like `f: int8 | slice = 5` or `f: int32 | int64 = 5 as int64` (to generate correct `$` labels).
+// So, if such a field exists, then we just assume it has no default.
+export function isDefaultValueSupported(fieldTy: Ty): boolean {
+    if (fieldTy.kind === 'arrayOf')     return isDefaultValueSupported(fieldTy.inner);
+    if (fieldTy.kind === 'lispListOf')  return isDefaultValueSupported(fieldTy.inner);
+    if (fieldTy.kind === 'tensor')      return fieldTy.items.every(isDefaultValueSupported);
+    if (fieldTy.kind === 'shapedTuple') return fieldTy.items.every(isDefaultValueSupported);
+
+    return fieldTy.kind !== 'union' && fieldTy.kind !== 'mapKV';
+}
+
+// Default values of fields (particularly, in storage) are precalculated by the compiler
+// and stored as "const expression" intermediate representation in ABI.
+// Here we output them to a valid TypeScript expression.
+// Default parameters for get methods follow the same logic, they are also "const expressions".
+export function emitFieldDefault(ctx: CodegenCtx, expr: ABIConstExpression): string {
+    switch (expr.kind) {
+        case 'int':         return expr.v + 'n';
+        case 'bool':        return expr.v ? 'true' : 'false';
+        case 'slice':       return `new c.Slice(new c.BitReader(new c.BitString(Buffer.from('${expr.hex}', 'hex'), 0, ${expr.hex.length * 4})), [])`;
+        case 'string':      return JSON.stringify(expr.str);
+        case 'address':     return `c.Address.parse('${expr.addr}')`;
+        case 'tensor':      return `[${expr.items.map(i => emitFieldDefault(ctx, i)).join(', ')}]`;
+        case 'shapedTuple': return `[${expr.items.map(i => emitFieldDefault(ctx, i)).join(', ')}]`;
+        case 'object': {
+            const structRef = ctx.symbols.getStruct(expr.structName);
+            return `{ $: '${structRef.name}', ${[...structRef.fields.map((f, i) =>
+                `${safeFieldDecl(f.name)}: ${emitFieldDefault(ctx, expr.fields[i])}`
+            )].join(', ')} }`;
+        }
+        case 'castTo':      return emitFieldDefault(ctx, expr.inner);
+        case 'null':        return `null`;
+    }
+}
+
+// Output a default value not as a TypeScript expression, but as a human-readable one.
+// For instance, "123" instead of bigint "123n".
+// It's inserted inside comments next to fields having defaults.
+export function emitFieldDefaultInComment(expr: ABIConstExpression): string {
+    switch (expr.kind) {
+        case 'int':         return expr.v;
+        case 'bool':        return expr.v ? 'true' : 'false';
+        case 'slice':       return `hex('${expr.hex}')`;
+        case 'string':      return JSON.stringify(expr.str);
+        case 'address':     return `address('${expr.addr}')`;
+        case 'tensor':      return `[${expr.items.map(emitFieldDefaultInComment).join(', ')}]`;
+        case 'shapedTuple': return `[${expr.items.map(emitFieldDefaultInComment).join(', ')}]`;
+        case 'object':      return `${expr.structName} { ${expr.fields.map(emitFieldDefaultInComment).join(', ')} }`;
+        case 'castTo':      return `${emitFieldDefaultInComment(expr.inner)} as ${renderTy(expr.castTo)}`;
+        case 'null':        return `null`;
+    }
+}