@neo-one/smart-contract-compiler/dist/cjs/utils/toABIReturn.js

NEO•ONE TypeScript smart contract compiler.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.toABIReturn = 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 analysis_1 = require("../analysis");
const types_1 = require("../compile/helper/types");
const DiagnosticCode_1 = require("../DiagnosticCode");
const DiagnosticMessage_1 = require("../DiagnosticMessage");
const getFixedDecimals_1 = require("./getFixedDecimals");
const getForwardedValueType_1 = require("./getForwardedValueType");
function toABIReturn(context, node, type, optionalIn = false, options = analysis_1.DEFAULT_DIAGNOSTIC_OPTIONS) {
    let resolvedType = type;
    if (resolvedType === undefined) {
        return undefined;
    }
    if (ts_utils_1.tsUtils.type_.isOnlyVoidish(resolvedType)) {
        return { type: 'Void', optional: false };
    }
    let optional = optionalIn;
    if (ts_utils_1.tsUtils.type_.hasUndefinedish(resolvedType)) {
        resolvedType = ts_utils_1.tsUtils.type_.getNonNullableType(resolvedType);
        optional = true;
    }
    let forwardedValue = false;
    if (context.builtins.isType(node, resolvedType, 'ForwardedValue')) {
        resolvedType = getForwardedValueType_1.getForwardedValueType(resolvedType);
        forwardedValue = true;
    }
    if (resolvedType === undefined) {
        return undefined;
    }
    if (ts_utils_1.tsUtils.type_.hasUndefinedish(resolvedType)) {
        resolvedType = ts_utils_1.tsUtils.type_.getNonNullableType(resolvedType);
        optional = true;
    }
    resolvedType = context.analysis.getNotAnyType(node, resolvedType);
    if (resolvedType === undefined) {
        return undefined;
    }
    if (types_1.isOnlyBoolean(context, node, resolvedType)) {
        return { type: 'Boolean', optional, forwardedValue };
    }
    if (context.builtins.isInterface(node, resolvedType, 'Address')) {
        return { type: 'Address', optional, forwardedValue };
    }
    if (context.builtins.isInterface(node, resolvedType, 'Hash256')) {
        return { type: 'Hash256', optional, forwardedValue };
    }
    if (context.builtins.isInterface(node, resolvedType, 'PublicKey')) {
        return { type: 'PublicKey', optional, forwardedValue };
    }
    if (types_1.isOnlyString(context, node, resolvedType)) {
        return { type: 'String', optional, forwardedValue };
    }
    if (ts_utils_1.tsUtils.type_.isOnlyNumberLiteral(resolvedType)) {
        return { type: 'Integer', optional, decimals: 0, forwardedValue };
    }
    if (context.builtins.isType(node, resolvedType, 'Fixed')) {
        const decimals = getFixedDecimals_1.getFixedDecimals(resolvedType);
        return { type: 'Integer', optional, decimals: decimals === undefined ? 0 : decimals, forwardedValue };
    }
    if (ts_utils_1.tsUtils.type_.isOnlyNumberish(resolvedType)) {
        return { type: 'Integer', optional, decimals: 0, forwardedValue };
    }
    if (types_1.isOnlyArray(context, node, resolvedType)) {
        const typeArguments = ts_utils_1.tsUtils.type_.getTypeArguments(resolvedType);
        if (typeArguments !== undefined) {
            const value = toABIReturn(context, node, typeArguments[0]);
            if (value !== undefined) {
                return { type: 'Array', optional, value, forwardedValue };
            }
        }
    }
    if (types_1.isOnlyMap(context, node, resolvedType)) {
        const typeArguments = ts_utils_1.tsUtils.type_.getTypeArguments(resolvedType);
        if (typeArguments !== undefined && typeArguments.length === 2) {
            const key = toABIReturn(context, node, typeArguments[0]);
            const value = toABIReturn(context, node, typeArguments[1]);
            if (key !== undefined && value !== undefined) {
                return { type: 'Map', optional, key, value, forwardedValue };
            }
        }
    }
    if (types_1.isOnlyBuffer(context, node, resolvedType)) {
        return { type: 'Buffer', optional, forwardedValue };
    }
    if (types_1.isOnlyForwardValue(context, node, resolvedType)) {
        return { type: 'ForwardValue', optional, forwardedValue };
    }
    if (types_1.isOnlyObject(context, node, resolvedType)) {
        const properties = ts_utils_1.tsUtils.type_.getProperties(resolvedType).reduce((acc, prop) => {
            const propType = context.analysis.getTypeOfSymbol(prop, node);
            const decls = ts_utils_1.tsUtils.symbol.getDeclarations(prop);
            const nextNode = decls.length === 0 ? node : decls[0];
            if (!typescript_1.default.isPropertyDeclaration(nextNode) && !typescript_1.default.isPropertySignature(nextNode)) {
                if (options.error) {
                    context.reportError(nextNode, DiagnosticCode_1.DiagnosticCode.InvalidContractType, DiagnosticMessage_1.DiagnosticMessage.InvalidContractType);
                }
                else if (options.warning) {
                    context.reportWarning(nextNode, DiagnosticCode_1.DiagnosticCode.InvalidContractType, DiagnosticMessage_1.DiagnosticMessage.InvalidContractType);
                }
                return acc;
            }
            const returnType = toABIReturn(context, nextNode, propType);
            return returnType === undefined ? acc : Object.assign(Object.assign({}, acc), { [ts_utils_1.tsUtils.symbol.getName(prop)]: returnType });
        }, {});
        return {
            type: 'Object',
            optional,
            forwardedValue,
            properties,
        };
    }
    if (options.error) {
        context.reportError(node, DiagnosticCode_1.DiagnosticCode.InvalidContractType, DiagnosticMessage_1.DiagnosticMessage.InvalidContractType);
    }
    else if (options.warning) {
        context.reportWarning(node, DiagnosticCode_1.DiagnosticCode.InvalidContractType, DiagnosticMessage_1.DiagnosticMessage.InvalidContractType);
    }
    return undefined;
}
exports.toABIReturn = toABIReturn;

//# sourceMappingURL=toABIReturn.js.map