@neo-one/smart-contract-compiler/dist/esm/compile/declaration/VariableDeclarationCompiler.js

NEO•ONE TypeScript smart contract compiler.

import { tsUtils } from '@neo-one/ts-utils';
import ts from 'typescript';
import { handleTypeAssignment } from '../helper/types';
import { NodeCompiler } from '../NodeCompiler';
export class VariableDeclarationCompiler extends NodeCompiler {
    constructor() {
        super(...arguments);
        this.kind = ts.SyntaxKind.VariableDeclaration;
    }
    visitNode(sb, node, options) {
        const nameNode = tsUtils.node.getNameNode(node);
        const expr = tsUtils.initializer.getInitializer(node);
        if (ts.isIdentifier(nameNode)) {
            sb.scope.add(tsUtils.node.getText(nameNode));
            if (expr === undefined) {
                if (!options.setValue) {
                    sb.emitHelper(node, sb.pushValueOptions(options), sb.helpers.wrapUndefined);
                }
            }
            else {
                sb.visit(expr, sb.pushValueOptions(options));
                if (ts.isIdentifier(nameNode)) {
                    handleTypeAssignment(sb.context, expr, node);
                }
            }
            sb.scope.set(sb, node, options, tsUtils.node.getText(nameNode));
            return;
        }
        if (expr === undefined) {
            return;
        }
        if (ts.isArrayBindingPattern(nameNode)) {
            sb.emitHelper(nameNode, options, sb.helpers.arrayBinding({
                type: sb.context.analysis.getType(expr),
                value: expr,
            }));
        }
        else {
            sb.emitHelper(nameNode, options, sb.helpers.objectBinding({
                type: sb.context.analysis.getType(expr),
                value: expr,
            }));
        }
    }
}

//# sourceMappingURL=VariableDeclarationCompiler.js.map