@mionjs/run-types 0.8.8 → 0.13.0

package/src/jitCompilers/binary/fromBinary.ts

@@ -1,492 +0,0 @@
-/* ########
- * 2025 mion
- * Author: Ma-jerez
- * License: MIT
- * The software is provided "as is", without warranty of any kind.
- * ######## */
-
-import {ReflectionKind} from '@deepkit/type';
-import {getJitUtils} from '@mionjs/core';
-import {ReflectionSubKind} from '../../constants.kind.ts';
-import {childIsExpression, createIfElseFn, isSafePropName, toLiteral} from '../../lib/utils.ts';
-import {jitBinaryDeserializerArgs, JitFunctions} from '../../constants.functions.ts';
-import {MAX_UNION_ITEMS} from '../../constants.ts';
-import type {JitCode} from '../../types.ts';
-import type {BaseRunType} from '../../lib/baseRunTypes.ts';
-import {type BaseFnCompiler} from '../../lib/jitFnCompiler.ts';
-import type {LiteralRunType} from '../../nodes/atomic/literal.ts';
-import type {ArrayRunType} from '../../nodes/member/array.ts';
-import type {PropertyRunType} from '../../nodes/member/property.ts';
-import type {InterfaceRunType} from '../../nodes/collection/interface.ts';
-import type {IndexSignatureRunType} from '../../nodes/member/indexProperty.ts';
-import type {ClassRunType} from '../../nodes/collection/class.ts';
-import type {TupleRunType} from '../../nodes/collection/tuple.ts';
-import type {ParameterRunType} from '../../nodes/member/param.ts';
-import type {RestParamsRunType} from '../../nodes/member/restParams.ts';
-import type {UnionRunType} from '../../nodes/collection/union.ts';
-import type {IterableRunType} from '../../nodes/native/Iterable.ts';
-import type {MapRunType} from '../../nodes/native/map.ts';
-
-type BinaryCompiler = BaseFnCompiler<typeof jitBinaryDeserializerArgs, typeof JitFunctions.fromBinary.id>;
-
-const fnID = JitFunctions.fromBinary.id;
-
-/**
- * Main Binary deserialization compiler function
- * Generates JIT code to deserialize Binary data to JavaScript values
- */
-export function emitFromBinary(runType: BaseRunType, comp: BinaryCompiler): JitCode {
-    const src = runType.src;
-    const kind = src.kind;
-    const dεs = comp.args.dεs;
-
-    // hack is used in some case to increase the index passing an extra argument to view.get methods
-    // ie: view.getUint32(index, littleEndian, index += 4);
-    // getUint32 only accepts 2 arguments, but we use the 3rd one to increase the index on a single statement so code can be used as an expression
-
-    switch (kind) {
-        // ###################### ATOMIC TYPES ######################
-        case ReflectionKind.unknown:
-        case ReflectionKind.any: {
-            // any is deserialized from json string
-            return {code: `JSON.parse(${dεs}.desString())`, type: 'E'};
-        }
-        case ReflectionKind.null:
-            return {code: `(${dεs}.index++, null)`, type: 'E'};
-        case ReflectionKind.boolean:
-            return {code: `${dεs}.view.getUint8(${dεs}.index++) === 1`, type: 'E'};
-        case ReflectionKind.number: {
-            return {code: `${dεs}.view.getFloat64(${dεs}.index, 1, (${dεs}.index += 8))`, type: 'E'};
-        }
-        case ReflectionKind.string: {
-            return {code: `${dεs}.desString()`, type: 'E'};
-        }
-        case ReflectionKind.bigint: {
-            return {code: `BigInt(${dεs}.desString(true))`, type: 'E'};
-        }
-        case ReflectionKind.undefined:
-        case ReflectionKind.void:
-            return {code: `(${dεs}.index++, undefined)`, type: 'E'};
-        case ReflectionKind.symbol: {
-            return {code: `Symbol(${dεs}.desString() || undefined)`, type: 'E'};
-        }
-        case ReflectionKind.regexp: {
-            return {code: `new RegExp(${dεs}.desString(), ${dεs}.desString())`, type: 'E'};
-        }
-        case ReflectionKind.object:
-            // similar to any, this is deserialized as json string
-            return {code: `JSON.parse(${dεs}.desString())`, type: 'E'};
-        case ReflectionKind.enum: {
-            return {code: `${dεs}.desEnum()`, type: 'E'};
-        }
-        case ReflectionKind.enumMember:
-            throw new Error('Binary deserialization not supported for enum member types');
-        case ReflectionKind.never:
-            throw new Error('Never type cannot be deserialized from Binary');
-        case ReflectionKind.templateLiteral:
-            throw new Error('Template literals are not supported in Binary deserialization');
-        case ReflectionKind.literal: {
-            if (comp.opts.noLiterals) {
-                const lit = (runType as LiteralRunType).src.literal;
-                if (lit instanceof RegExp) return emitFromBinaryAs(runType, comp, ReflectionKind.regexp);
-                switch (typeof lit) {
-                    case 'string':
-                        return emitFromBinaryAs(runType, comp, ReflectionKind.string);
-                    case 'number':
-                        return emitFromBinaryAs(runType, comp, ReflectionKind.number);
-                    case 'boolean':
-                        return emitFromBinaryAs(runType, comp, ReflectionKind.boolean);
-                    case 'bigint':
-                        return emitFromBinaryAs(runType, comp, ReflectionKind.bigint);
-                    case 'symbol':
-                        return emitFromBinaryAs(runType, comp, ReflectionKind.symbol);
-                    default:
-                        throw new Error(`Unsupported literal type ${typeof lit}`);
-                }
-            }
-            return {code: toLiteral((runType as LiteralRunType).src.literal), type: 'E'};
-        }
-
-        // ###################### MEMBER RUNTYPES ######################
-        // Types that represent members of collections or other structures
-        case ReflectionKind.rest: // rest params are deserialized as array but start at rest item index
-        case ReflectionKind.array: {
-            const rt = runType as ArrayRunType | RestParamsRunType;
-            rt.checkNonSkipTypes(comp);
-            const child = rt.getMemberType()!;
-            const childCode = comp.compile(child, 'S', fnID);
-            if (!childCode?.code) throw new Error(`Do not know how to deserialize Array<${child.getTypeName()}> from Binary.`);
-            const isRest = rt.src.kind === ReflectionKind.rest;
-            const index = rt.getChildVarName(comp);
-            const isExpression = childIsExpression(childCode, child);
-            const code = isExpression ? `${comp.getChildVλl()} = ${childCode.code};` : childCode.code;
-            // deserialized from [length, items...]
-            const lengthVal = comp.getLocalVarName('arrL', rt);
-            const arrayInit = isRest ? '' : `${comp.vλl} = new Array(${lengthVal})`; // res array already initialized in parent
-            return {
-                code: `
-                const ${lengthVal} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4; ${arrayInit};
-                for (let ${index} = ${rt.startIndex(comp)}; ${index} < ${lengthVal}; ${index}++) {${code}}
-            `,
-                type: 'S',
-            };
-        }
-
-        case ReflectionKind.indexSignature: {
-            const rt = runType as IndexSignatureRunType;
-            const indexKind = (rt.src as any).index?.kind;
-            const memberCode = comp.compile(rt.getJitChild(comp), 'S', fnID);
-            if (!memberCode?.code) return {code: undefined, type: 'E'};
-
-            const prop = rt.getChildVarName(comp);
-            const countVar = comp.getLocalVarName('cnt', rt);
-            const indexVar = comp.getLocalVarName('propI', rt);
-
-            // Deserialize key based on index type
-            let keyDeserializationCode: string;
-            if (indexKind === ReflectionKind.number) {
-                // For number indices, deserialize as uint32
-                keyDeserializationCode = `const ${prop} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4;`;
-            } else {
-                // For string indices, deserialize as string with prototype pollution protection
-                keyDeserializationCode = `const ${prop} = ${dεs}.desSafePropName();`;
-            }
-
-            const memberInit = memberCode.type === 'E' ? `${comp.vλl}[${prop}] = ${memberCode.code};` : memberCode.code;
-            const deserializeCode = `for (let ${indexVar} = 0; ${indexVar} < ${countVar}; ${indexVar}++) {${keyDeserializationCode}${memberInit}}`;
-
-            return {
-                code: `const ${countVar} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4; ${comp.vλl} = {}; ${deserializeCode}`,
-                type: 'S',
-            };
-        }
-
-        case ReflectionKind.function:
-        case ReflectionKind.method:
-        case ReflectionKind.methodSignature:
-        case ReflectionKind.callSignature:
-            if (runType.src.subKind === ReflectionSubKind.params) {
-                return emitFromBinaryAs(runType, comp, ReflectionKind.tuple);
-            } else {
-                throw new Error(
-                    'Binary deserialization not supported for functions, call compileParams or compileReturn instead.'
-                );
-            }
-
-        case ReflectionKind.parameter: {
-            const rt = runType as ParameterRunType;
-            switch (src.subKind) {
-                case ReflectionSubKind.mapKey:
-                case ReflectionSubKind.mapValue:
-                case ReflectionSubKind.setItem: {
-                    const child = rt.getJitChild(comp);
-                    const childJit = comp.compile(child, 'S', fnID);
-                    if (!childJit?.code || !child)
-                        throw new Error(`Do not know how to deserialize ${rt.getTypeName()} from Binary.`);
-                    const parent = rt.getParent()!;
-                    const parentVλl = parent.getCustomVλl(comp)?.vλl || comp.vλl;
-                    const vλl = rt.getCustomVλl(comp)?.vλl;
-                    const isExpression = childIsExpression(childJit, child);
-                    const code = isExpression ? `const ${vλl} = ${childJit.code};` : childJit.code || '';
-                    let setOperation = '';
-                    switch (rt.src.subKind) {
-                        case ReflectionSubKind.mapKey:
-                            break; // we set map item once we have the key and value
-                        case ReflectionSubKind.mapValue: {
-                            const mapKey = (parent as MapRunType).getMapKeyVλl(comp); // not the best solution but works
-                            setOperation = `${parentVλl}.set(${mapKey}, ${vλl})`;
-                            break;
-                        }
-                        case ReflectionSubKind.setItem:
-                            setOperation = `${parentVλl}.add(${vλl})`;
-                            break;
-                    }
-                    return {code: `${code}; ${setOperation};`, type: 'S'};
-                }
-                default:
-                    return emitFromBinaryAs(runType, comp, ReflectionKind.tupleMember);
-            }
-        }
-
-        case ReflectionKind.property:
-        case ReflectionKind.propertySignature: {
-            const rt = runType as PropertyRunType;
-            const parent = rt.getParent() as InterfaceRunType;
-            const child = rt.getJitChild(comp)!;
-            const childJit = comp.compile(child, 'S', fnID);
-            if (rt.isOptional()) {
-                const {bitMIndexVar, bitIndex} = getOptionalBitmapItems(parent, comp, 0, rt.optionalIndex, false);
-                const initCode = childJit.type === 'E' ? `${comp.getChildVλl()} = ${childJit.code};` : childJit.code;
-                return {
-                    code: `if (${dεs}.view.getUint8(${bitMIndexVar}, 1) & (1 << (${bitIndex}))) {${initCode}}`,
-                    type: 'S',
-                };
-            }
-            // block or statements code are initialized as obj.a = deserializeA; obj.b = deserializeB; after initial object has been created
-            const isExpression = childIsExpression(childJit, child);
-            if (!isExpression) {
-                return childJit; // block statements already include variable assignment
-            }
-            // required props that are simple expressions code are part of an object constructor {a: deserializeA, b: deserializeB, c: deserializeC}
-            const propName = getPropName(rt, comp, true);
-            return {code: `${propName}:${childJit?.code}`, type: 'E'};
-        }
-
-        case ReflectionKind.tupleMember: {
-            const rt = runType as ParameterRunType;
-            const childJit = comp.compile(rt.getJitChild(comp), 'S', fnID);
-            const nullJIt = emitFromBinaryAs(rt, comp, ReflectionKind.undefined);
-            const itemJit = childJit?.code ? childJit : nullJIt; // if child is not serializable, we serialize null as need to fill the space in the tuple
-            const initCode = itemJit.type === 'E' ? `${comp.getChildVλl()} = ${itemJit.code}` : itemJit.code;
-            if (rt.isRest()) return itemJit;
-            // Optional handling uses bitmap set at tuple level
-            const optionalIndex = (rt as any).optionalIndex;
-            const bitMIndexVar = (rt as any)._bitmapVar;
-            const isFnParam = (rt as any)._isFnParam;
-            // Treat as optional if either isOptional() is true OR it's a function param (all fn params are optional in binary)
-            const isOptional = rt.isOptional() || isFnParam;
-            if (isOptional && optionalIndex !== undefined && bitMIndexVar) {
-                const bitIndex = optionalIndex & 7; // equivalent to optionalIndex % 8
-                const code = `if (${dεs}.view.getUint8(${bitMIndexVar}, 1) & (1 << (${bitIndex}))) {${initCode}}`;
-                return {code, type: 'S'};
-            }
-            return {code: initCode, type: 'S'};
-        }
-        case ReflectionKind.promise:
-            throw new Error('Jit compilation disabled for Non Serializable types.');
-
-        // ###################### COLLECTION RUNTYPES ######################
-        // Types that contain other types as members
-        case ReflectionKind.objectLiteral:
-        case ReflectionKind.intersection: {
-            const rt = runType as InterfaceRunType;
-            if (rt.isCallable()) return comp.compile(rt.getCallSignature(), 'S', fnID);
-            if (runType.src.subKind === ReflectionSubKind.nonSerializable) {
-                throw new Error('Binary deserialization is disabled for Non Serializable types');
-            } else {
-                const {required, optional, indexSignatures} = rt.splitJitSplitChildren(comp);
-                if (indexSignatures.length) {
-                    return comp.compile(indexSignatures[0], 'S', fnID); // index signature code already contains the loop
-                }
-
-                // required props that are simple expressions are restored as: '{a: deserializeA, b: deserializeB, c: deserializeC};
-                // and are serialized/deserialised in the same order they are declared in the type
-                const requiredItemsJit = required.map((prop) => comp.compile(prop, 'S', fnID));
-                const expressionItemsJit = requiredItemsJit
-                    .filter((childJit, i) => childIsExpression(childJit, required[i]))
-                    .map((prop) => prop.code)
-                    .filter(Boolean);
-                const statementItemsCode = requiredItemsJit
-                    .filter(Boolean)
-                    .filter((childJit, i) => !childIsExpression(childJit, required[i]))
-                    .map((prop) => prop.code);
-                const expressionsPropsCode = expressionItemsJit.join(',');
-                const requiredPropsCode = statementItemsCode.join(';');
-
-                // optional props are initialized as obj.a = deserializeA; obj.b = deserializeB; obj.c = deserializeC;
-                // bitmap is used to determine which optional props are present
-                // header format: [bitmap, optional props]
-                let optionalPropsCode = '';
-                if (optional.length) {
-                    // optional properties are restored using a loop
-                    const {bitMapInit, bitMIndexVar} = getOptionalBitmapItems(rt, comp, optional.length, 0, false);
-                    const propsCode = optional
-                        .map((prop, i) => {
-                            prop.optionalIndex = i;
-                            const modIndex = i + 1;
-                            const shouldIncreaseBufferIndex = modIndex % 8 === 0;
-                            const propCode = comp.compile(prop, 'S', fnID).code;
-                            if (!shouldIncreaseBufferIndex) return propCode;
-                            // every 8 props we need to increase the bitmap index
-                            return `${propCode} ${bitMIndexVar}++; `;
-                        })
-                        .filter(Boolean)
-                        .join('');
-                    const sep = requiredPropsCode ? ';' : '';
-                    optionalPropsCode = `${sep}\n${bitMapInit}\n${propsCode}`;
-                }
-
-                const canBeExpression = !requiredPropsCode && !optionalPropsCode;
-                if (canBeExpression) return {code: `{${expressionsPropsCode}}`, type: 'E'};
-                return {code: `${comp.vλl} = {${expressionsPropsCode}}\n${requiredPropsCode}${optionalPropsCode}`, type: 'S'};
-            }
-        }
-        case ReflectionKind.class:
-            switch (runType.src.subKind) {
-                case ReflectionSubKind.date:
-                    return {code: `new Date(${dεs}.view.getFloat64(${dεs}.index, 1, (${dεs}.index += 8)))`, type: 'E'};
-                case ReflectionSubKind.map:
-                case ReflectionSubKind.set: {
-                    const rt = runType as IterableRunType;
-                    const children = rt.getJitChildren(comp);
-                    const vλl = rt.getCustomVλl(comp)?.vλl || comp.vλl;
-                    const initCode = `const ${vλl} = new ${rt.constructorName}()`;
-                    if (!children.length) return {code: `new ${rt.constructorName}()`, type: 'E'};
-                    const childrenCode = children
-                        .map((c) => comp.compile(c, 'S', fnID).code)
-                        .filter(Boolean)
-                        .join(';');
-                    if (!childrenCode) return {code: initCode, type: 'E'};
-                    const index = comp.getLocalVarName('itI', rt);
-                    const lengthVar = comp.getLocalVarName('itL', rt);
-                    const readLength = `const ${lengthVar} = ${dεs}.view.getUint32(${dεs}.index, 1); ${dεs}.index += 4`;
-                    return {
-                        code: `${initCode}; ${readLength}; for (let ${index} = 0; ${index} < ${lengthVar}; ${index}++) {${childrenCode}} ${comp.vλl} = ${vλl};`,
-                        type: 'S',
-                    };
-                }
-                case ReflectionSubKind.nonSerializable:
-                    throw new Error('Binary deserialization disabled for Non Serializable types');
-                default: {
-                    const rt = runType as ClassRunType;
-                    if (rt.isCallable()) {
-                        const callSignature = rt.getCallSignature();
-                        if (callSignature) return comp.compile(callSignature, 'S', fnID);
-                    }
-                    const originalKind = rt.src.kind;
-                    (runType.src as any).kind = ReflectionKind.objectLiteral;
-                    const plainObjCode = emitFromBinary(rt, comp);
-                    (runType.src as any).kind = originalKind;
-                    const desFnVarName = comp.getLocalVarName('desFn', rt);
-                    const desFnInit = `let ${desFnVarName} = utl.${getJitUtils().getDeserializeFn.name}(${toLiteral(rt.getClassName())})`;
-                    const desFnCode = `if (${desFnVarName}) {${comp.vλl} = ${desFnVarName}(${comp.vλl})}`;
-                    const desClassCode = `else if (${desFnVarName} = utl.${getJitUtils().getSerializeClass.name}(${toLiteral(rt.getClassName())})) {${comp.vλl} = new ${desFnVarName}(${comp.vλl})}`;
-                    const initCode = plainObjCode.type === 'E' ? `${comp.vλl} = ${plainObjCode.code}` : plainObjCode.code;
-                    return {code: `${initCode};${desFnInit};${desFnCode} ${desClassCode}`, type: 'S'};
-                }
-            }
-            break;
-
-        case ReflectionKind.infer:
-            throw new Error('Infer is not supported in Binary deserialization');
-
-        case ReflectionKind.tuple: {
-            const rt = runType as TupleRunType;
-            const skip = rt.skipJit(comp);
-            if (skip) return {code: undefined, type: 'S'};
-            const params = rt.getParamRunTypes(comp);
-
-            // For function params, all params are treated as optional in binary serialization
-            // This allows sending null/undefined values over the wire even if the type is not optional
-            const isFnParams = runType.src.subKind === ReflectionSubKind.params;
-
-            // For function params, all params are optional so we can't use fixed size
-            const hasFixedSize = !isFnParams && params.every((p) => !p.isOptional() && !p.isRest());
-            const initTuple = hasFixedSize ? `${comp.vλl} = new Array(${params.length});` : `${comp.vλl} = [];`;
-            if (params.length === 0) return {code: initTuple, type: 'S'};
-
-            // Split params into required, optional, and rest
-            // For function params, all non-rest params are treated as optional
-            const required = isFnParams ? [] : params.filter((p) => !p.isOptional() && !p.isRest());
-            const optional = isFnParams ? params.filter((p) => !p.isRest()) : params.filter((p) => p.isOptional() && !p.isRest());
-            const rest = params.filter((p) => p.isRest());
-
-            // Deserialize required params first
-            const requiredCode = required.map((p) => comp.compile(p, 'S', fnID).code || '').join(';');
-
-            // Deserialize optional params with bitmap (groups of 8)
-            let optionalCode = '';
-            if (optional.length) {
-                const {bitMapInit, bitMIndexVar} = getOptionalBitmapItems(rt, comp, optional.length, 0, true);
-                const optionalParamsCode = optional
-                    .map((p, i) => {
-                        (p as any).optionalIndex = i; // set optionalIndex for use in tupleMember case
-                        (p as any)._bitmapVar = bitMIndexVar; // pass bitmap variable name to tupleMember case
-                        (p as any)._isFnParam = isFnParams; // flag to indicate this is a function param
-                        const paramCode = comp.compile(p, 'S', fnID).code || '';
-                        const modIndex = i + 1;
-                        const shouldIncreaseBufferIndex = modIndex % 8 === 0 && modIndex < optional.length;
-                        const increaseIndex = shouldIncreaseBufferIndex ? `${bitMIndexVar}++;` : '';
-                        return `${paramCode} ${increaseIndex}`;
-                    })
-                    .join('');
-                optionalCode = `${bitMapInit}\n${optionalParamsCode}`;
-            }
-
-            // Deserialize rest params (handled as array by the rest param itself)
-            const restCode = rest.map((p) => comp.compile(p, 'S', fnID).code || '').join(';');
-
-            const allCode = [requiredCode, optionalCode, restCode].filter(Boolean).join(';');
-            return {code: `${initTuple}${allCode}`, type: 'S'};
-        }
-        case ReflectionKind.typeParameter:
-            throw new Error('Type parameter not implemented in Binary deserialization');
-
-        case ReflectionKind.union: {
-            const rt = runType as UnionRunType;
-            rt.checkAllowedChildren(comp);
-            const decVar = comp.getLocalVarName('dec', rt);
-            const errVarName = comp.getLocalVarName('uErr', rt);
-            comp.setContextItem(errVarName, `const ${errVarName} = "Can not binary decode union: invalid union index"`);
-            const children = rt.getJitChildren(comp);
-            if (children.length > MAX_UNION_ITEMS) {
-                throw new Error(
-                    `Binary deserialization not supported for Union with more than ${MAX_UNION_ITEMS} items.` +
-                        ` Found ${children.length} in ${rt.getUnionTypeNames()}`
-                );
-            }
-            const maxIndex = children.length - 1;
-            const isUint16 = maxIndex > 255;
-            const readIndex = isUint16
-                ? `const ${decVar} = ${dεs}.view.getUint16(${dεs}.index, 1); ${dεs}.index += 2;`
-                : `const ${decVar} = ${dεs}.view.getUint8(${dεs}.index++);`;
-            const ifElse = createIfElseFn();
-            const itemsCode = children
-                .map((unionItem) => {
-                    const childJit = comp.compile(unionItem, 'S', fnID);
-                    const isExpression = childIsExpression(childJit, unionItem);
-                    const code =
-                        isExpression && childJit.code && childJit.code !== comp.vλl
-                            ? `${comp.vλl} = ${childJit.code}`
-                            : childJit.code || '';
-                    const index = rt.getUnionItemIndex(comp, unionItem);
-                    return `${ifElse()} (${decVar} === ${index}) {${code || '/*noop*/'}}`;
-                })
-                .filter(Boolean);
-            const childrenCode = itemsCode.join('');
-            const failCode = childrenCode ? `else {throw new Error(${errVarName})}` : '';
-            const code = `
-                ${readIndex}
-                ${childrenCode}
-                ${failCode}
-            `;
-            return {code, type: 'S'};
-        }
-
-        default:
-            throw new Error(`Binary deserialization not supported for ${ReflectionKind[kind]} types`);
-    }
-    throw new Error(`Do not know how to deserialize ${runType.getTypeName()} from Binary.`);
-}
-
-function getPropName(rt: PropertyRunType, comp: BinaryCompiler, isObjectConstructor: boolean): string | number {
-    const isSafe = isSafePropName(rt.src.name);
-    if (isObjectConstructor) return isSafe ? rt.getChildVarName(comp) : rt.getChildLiteral(comp);
-    return isSafe ? `.${rt.getChildVarName(comp)}` : `[${rt.getChildLiteral(comp)}]`;
-}
-
-/** Generates bitmap reading code for optional properties/params. Uses 1 bit per optional item (8 items per byte). */
-function getOptionalBitmapItems(
-    rt: InterfaceRunType | TupleRunType,
-    comp: BinaryCompiler,
-    optionalLength = 0,
-    currentIndex = 0,
-    isTuple = false
-) {
-    const dεs = comp.args.dεs;
-    const prefix = isTuple ? 't' : '';
-    const bitMIndexVar = comp.getLocalVarName(`${prefix}bimI`, rt); // index of the bitmap
-    const bitmapLength = Math.ceil(optionalLength / 8);
-    const bitIndex = `${currentIndex} & 7`; // equivalent to index % 8
-    // bitmap for present optional items
-    const bitMapInit = `${bitmapLength > 1 ? 'let ' : 'const'} ${bitMIndexVar} = ${dεs}.index; ${dεs}.index += ${bitmapLength};`;
-    return {bitMIndexVar, bitmapLength, bitIndex, bitMapInit};
-}
-
-function emitFromBinaryAs(rt: BaseRunType, comp: BinaryCompiler, kind: ReflectionKind): JitCode {
-    const originalKind = rt.src.kind;
-    (rt.src as any).kind = kind;
-    const result = emitFromBinary(rt, comp);
-    (rt.src as any).kind = originalKind;
-    return result;
-}