@neo-one/smart-contract-compiler-esnext-esm/compile/helper/types/UnwrapValRecursiveHelper.js

NEO•ONE TypeScript smart contract compiler.

import { tsUtils } from '@neo-one/ts-utils-esnext-esm';
import { Helper } from '../Helper';
import { isOnlyMap } from './map';
export class UnwrapValRecursiveHelper extends Helper {
    constructor(options) {
        super();
        this.type = options.type;
    }
    emit(sb, node, options) {
        if (this.type === undefined) {
            return;
        }
        if (!options.pushValue) {
            sb.emitOp(node, 'DROP');
        }
        const type = tsUtils.type_.getNonNullableType(this.type);
        sb.emitHelper(node, options, sb.helpers.forBuiltinType({
            type: this.type,
            array: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapArray);
                sb.emitHelper(node, innerOptions, sb.helpers.arrMap({
                    map: (innerInnerOptions) => {
                        const localArrayType = tsUtils.type_.getArrayType(type);
                        const arrayType = localArrayType === undefined ? undefined : sb.context.analysis.getNotAnyType(node, localArrayType);
                        sb.emitHelper(node, innerInnerOptions, sb.helpers.unwrapValRecursive({ type: arrayType }));
                    },
                }));
            },
            arrayStorage: (innerOptions) => {
                sb.emitOp(node, 'DROP');
                sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
            },
            boolean: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapBoolean);
            },
            buffer: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapBuffer);
            },
            null: () => {
                sb.emitOp(node, 'DROP');
                sb.emitPushBuffer(node, Buffer.from([]));
            },
            number: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapNumber);
            },
            object: (innerOptions) => {
                sb.emitOp(node, 'NEWMAP');
                tsUtils.type_.getProperties(type).forEach((prop) => {
                    const propType = sb.context.analysis.getTypeOfSymbol(prop, node);
                    sb.emitOp(node, 'TUCK');
                    sb.emitOp(node, 'OVER');
                    sb.emitPushString(node, tsUtils.symbol.getName(prop));
                    sb.emitOp(node, 'TUCK');
                    sb.emitHelper(node, innerOptions, sb.helpers.getPropertyObjectProperty);
                    sb.emitHelper(node, innerOptions, sb.helpers.unwrapValRecursive({ type: propType }));
                    sb.emitOp(node, 'SETITEM');
                    sb.emitOp(node, 'SWAP');
                });
                sb.emitOp(node, 'NIP');
            },
            string: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapString);
            },
            symbol: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapSymbol);
            },
            undefined: () => {
                sb.emitOp(node, 'DROP');
                sb.emitPushBuffer(node, Buffer.from([]));
            },
            map: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapMap);
                sb.emitHelper(node, innerOptions, sb.helpers.mapMap({
                    map: (innerInnerOptions) => {
                        let keyType;
                        let valueType;
                        if (isOnlyMap(sb.context, node, type)) {
                            const localKeyType = tsUtils.type_.getTypeArgumentsArray(type)[0];
                            keyType =
                                localKeyType === undefined ? undefined : sb.context.analysis.getNotAnyType(node, localKeyType);
                            const localValueType = tsUtils.type_.getTypeArgumentsArray(type)[1];
                            valueType =
                                localValueType === undefined ? undefined : sb.context.analysis.getNotAnyType(node, localValueType);
                        }
                        sb.emitHelper(node, innerInnerOptions, sb.helpers.unwrapValRecursive({ type: keyType }));
                        sb.emitOp(node, 'SWAP');
                        sb.emitHelper(node, innerInnerOptions, sb.helpers.unwrapValRecursive({ type: valueType }));
                        sb.emitOp(node, 'SWAP');
                    },
                }));
            },
            mapStorage: (innerOptions) => {
                sb.emitOp(node, 'DROP');
                sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
            },
            set: (innerOptions) => {
                sb.emitOp(node, 'DROP');
                sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
            },
            setStorage: (innerOptions) => {
                sb.emitOp(node, 'DROP');
                sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
            },
            error: (innerOptions) => {
                sb.emitOp(node, 'DROP');
                sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
            },
            forwardValue: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapForwardValue);
            },
            iteratorResult: (innerOptions) => {
                sb.emitOp(node, 'DROP');
                sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
            },
            iterableIterator: (innerOptions) => {
                sb.emitOp(node, 'DROP');
                sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
            },
            iterable: (innerOptions) => {
                sb.emitOp(node, 'DROP');
                sb.emitHelper(node, innerOptions, sb.helpers.throwTypeError);
            },
            transaction: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapTransaction);
            },
            output: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapOutput);
            },
            attribute: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapAttribute);
            },
            input: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapInput);
            },
            account: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapAccount);
            },
            asset: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapAsset);
            },
            contract: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapContract);
            },
            header: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapHeader);
            },
            block: (innerOptions) => {
                sb.emitHelper(node, innerOptions, sb.helpers.unwrapBlock);
            },
        }));
    }
}

//# sourceMappingURL=UnwrapValRecursiveHelper.js.map