@neo-one/smart-contract-compiler/dist/cjs/compile/statement/ForInStatementCompiler.js

NEO•ONE TypeScript smart contract compiler.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ForInStatementCompiler = void 0;
const tslib_1 = require("tslib");
const ts_utils_1 = require("@neo-one/ts-utils");
const typescript_1 = tslib_1.__importDefault(require("typescript"));
const NodeCompiler_1 = require("../NodeCompiler");
class ForInStatementCompiler extends NodeCompiler_1.NodeCompiler {
    constructor() {
        super(...arguments);
        this.kind = typescript_1.default.SyntaxKind.ForInStatement;
    }
    visitNode(sb, node, optionsIn) {
        const options = sb.pushValueOptions(optionsIn);
        const initializer = ts_utils_1.tsUtils.statement.getInitializer(node);
        if (!typescript_1.default.isVariableDeclarationList(initializer)) {
            sb.context.reportUnsupported(initializer);
            return;
        }
        const variables = ts_utils_1.tsUtils.variable.getDeclarations(initializer);
        if (variables.length !== 1) {
            sb.context.reportUnsupported(initializer);
            return;
        }
        const variable = variables[0];
        const expression = ts_utils_1.tsUtils.expression.getExpression(node);
        const statement = ts_utils_1.tsUtils.statement.getStatement(node);
        const expressionType = sb.context.analysis.getType(expression);
        const handleArray = () => {
            sb.emitHelper(expression, options, sb.helpers.unwrapArray);
            sb.emitHelper(node, options, sb.helpers.arrForEach({
                withIndex: true,
                each: (innerOptions) => {
                    sb.emitOp(variable, 'DROP');
                    sb.emitHelper(variable, options, sb.helpers.wrapNumber);
                    sb.emitHelper(variable, options, sb.helpers.toString({ type: undefined }));
                    sb.emitHelper(variable, options, sb.helpers.wrapString);
                    sb.visit(variable, sb.setValueOptions(innerOptions));
                    sb.visit(statement, sb.noPushValueOptions(innerOptions));
                },
            }));
        };
        const handleObject = () => {
            sb.emitHelper(node, options, sb.helpers.getPropertyObjectKeys);
            sb.emitHelper(node, options, sb.helpers.arrForEach({
                withIndex: false,
                each: (innerOptions) => {
                    sb.emitHelper(variable, sb.pushValueOptions(innerOptions), sb.helpers.wrapString);
                    sb.visit(variable, sb.setValueOptions(sb.noPushValueOptions(innerOptions)));
                    sb.visit(statement, sb.noPushValueOptions(innerOptions));
                },
            }));
        };
        sb.visit(expression, options);
        if (expressionType === undefined ||
            (ts_utils_1.tsUtils.type_.hasArrayish(expressionType) && !ts_utils_1.tsUtils.type_.isOnlyArrayish(expressionType))) {
            sb.emitHelper(expression, options, sb.helpers.if({
                condition: () => {
                    sb.emitOp(expression, 'DUP');
                    sb.emitHelper(expression, options, sb.helpers.isArray);
                },
                whenTrue: handleArray,
                whenFalse: handleObject,
            }));
        }
        else if (ts_utils_1.tsUtils.type_.isOnlyArrayish(expressionType)) {
            handleArray();
        }
        else {
            handleObject();
        }
    }
}
exports.ForInStatementCompiler = ForInStatementCompiler;

//# sourceMappingURL=ForInStatementCompiler.js.map