@idlizer/core 2.0.15

package/build/lib/src/LanguageWriters/ArgConvertors.js

@@ -0,0 +1,1015 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as idl from "../idl";
+import { Language } from "../Language";
+import { PrintHint, BlockStatement, StringExpression } from "./LanguageWriter";
+import { RuntimeType } from "./common";
+import { generatorTypePrefix } from "../config";
+import { hashCodeFromString, warn } from "../util";
+import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
+import { InteropNameConvertor } from "./InteropConvertor";
+import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { CppInteropConvertor } from "./convertors/CppConvertors";
+import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
+export class BaseArgConvertor {
+    constructor(idlType, runtimeTypes, isScoped, useArray, param) {
+        this.idlType = idlType;
+        this.runtimeTypes = runtimeTypes;
+        this.isScoped = isScoped;
+        this.useArray = useArray;
+        this.param = param;
+    }
+    nativeType() {
+        throw new Error("Define");
+    }
+    isPointerType() {
+        throw new Error("Define");
+    }
+    interopType() {
+        throw new Error("Define");
+    }
+    targetType(writer) {
+        return writer.getNodeName(this.idlType);
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return undefined;
+    }
+    getMembers() { return []; }
+    getObjectAccessor(language, value, args, writer) {
+        if (writer)
+            return writer.getObjectAccessor(this, value, args);
+        return this.useArray && (args === null || args === void 0 ? void 0 : args.index) ? `${value}[${args.index}]` : value;
+    }
+    discriminatorFromFields(value, writer, uniqueFields, nameAccessor, optionalAccessor, duplicates) {
+        if (!uniqueFields || uniqueFields.length === 0)
+            return undefined;
+        const firstNonOptional = uniqueFields.find(it => !optionalAccessor(it));
+        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [
+            writer.makeDiscriminatorFromFields(this, value, firstNonOptional ? [nameAccessor(firstNonOptional)] : uniqueFields.map(it => nameAccessor(it)), duplicates)
+        ]);
+    }
+}
+export class BooleanConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(idl.IDLBooleanType, [RuntimeType.BOOLEAN], false, false, param);
+    }
+    convertorArg(param, writer) {
+        return writer.castToBoolean(param);
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, "writeBoolean", [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeString(`${deserializerName}.readBoolean()`));
+    }
+    nativeType() {
+        return idl.IDLBooleanType;
+    }
+    interopType() {
+        return idl.IDLBooleanType;
+    }
+    isPointerType() {
+        return false;
+    }
+}
+export class UndefinedConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(idl.IDLUndefinedType, [RuntimeType.UNDEFINED], false, false, param);
+    }
+    convertorArg(param, writer) {
+        return writer.makeUndefined().asString();
+    }
+    convertorSerialize(param, value, printer) { }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeUndefined());
+    }
+    nativeType() {
+        return idl.IDLUndefinedType;
+    }
+    interopType() {
+        return idl.IDLUndefinedType;
+    }
+    isPointerType() {
+        return false;
+    }
+}
+export class VoidConvertor extends UndefinedConvertor {
+    convertorArg(param, writer) {
+        return writer.makeVoid().asString();
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeVoid());
+    }
+    nativeType() {
+        return idl.IDLVoidType;
+    }
+}
+export class StringConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(idl.IDLStringType, [RuntimeType.STRING], false, false, param);
+    }
+    convertorArg(param, writer) {
+        return writer.language == Language.CPP
+            ? writer.makeUnsafeCast_(writer.makeString(`&${param}`), this.idlType, PrintHint.AsConstPointer)
+            : param;
+    }
+    convertorSerialize(param, value, writer) {
+        writer.writeMethodCall(`${param}Serializer`, `writeString`, [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readString()`), this.idlType, { optional: false }));
+    }
+    nativeType() {
+        return idl.IDLStringType;
+    }
+    interopType() {
+        return idl.IDLStringType;
+    }
+    isPointerType() {
+        return true;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return this.literalValue
+            ? writer.makeString(`${value} === "${this.literalValue}"`)
+            : undefined;
+    }
+    targetType(writer) {
+        if (this.literalValue) {
+            return writer.getNodeName(idl.IDLStringType);
+        }
+        return super.targetType(writer);
+    }
+}
+export class EnumConvertor extends BaseArgConvertor {
+    constructor(param, enumEntry) {
+        super(idl.createReferenceType(enumEntry.name, undefined, enumEntry), [idl.isStringEnum(enumEntry) ? RuntimeType.STRING : RuntimeType.NUMBER], false, false, param);
+        this.enumEntry = enumEntry;
+    }
+    convertorArg(param, writer) {
+        return writer.makeEnumCast(param, false, this);
+    }
+    convertorSerialize(param, value, writer) {
+        value =
+            idl.isStringEnum(this.enumEntry)
+                ? writer.ordinalFromEnum(writer.makeString(value), idl.createReferenceType(this.enumEntry.name, undefined, this.enumEntry)).asString()
+                : writer.makeEnumCast(value, false, this);
+        writer.writeMethodCall(`${param}Serializer`, "writeInt32", [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const readExpr = writer.makeMethodCall(`${deserializerName}`, "readInt32", []);
+        const enumExpr = idl.isStringEnum(this.enumEntry)
+            ? writer.enumFromOrdinal(readExpr, idl.createReferenceType(this.enumEntry.name, undefined, this.enumEntry))
+            : writer.makeCast(readExpr, idl.createReferenceType(this.enumEntry.name, undefined, this.enumEntry));
+        return assigneer(enumExpr);
+    }
+    nativeType() {
+        return idl.createReferenceType(this.enumEntry.name, undefined, this.enumEntry);
+    }
+    interopType() {
+        return idl.IDLI32Type;
+    }
+    isPointerType() {
+        return false;
+    }
+    targetType(writer) {
+        return writer.getNodeName(this.idlType); // this.enumTypeName(writer.language)
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return writer.makeDiscriminatorConvertor(this, value, index);
+    }
+}
+export class NumberConvertor extends BaseArgConvertor {
+    constructor(param) {
+        // TODO: as we pass tagged values - request serialization to array for now.
+        // Optimize me later!
+        super(idl.IDLNumberType, [RuntimeType.NUMBER], false, false, param);
+    }
+    convertorArg(param, writer) {
+        return writer.language == Language.CPP
+            ? writer.makeUnsafeCast_(writer.makeString(`&${param}`), this.idlType, PrintHint.AsConstPointer)
+            : param;
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, "writeNumber", [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readNumber()`), this.idlType, { optional: false }));
+    }
+    nativeType() {
+        return idl.IDLNumberType;
+    }
+    interopType() {
+        return idl.IDLNumberType;
+    }
+    isPointerType() {
+        return true;
+    }
+}
+export class NumericConvertor extends BaseArgConvertor {
+    constructor(param, type) {
+        // check numericPrimitiveTypes.include(type)
+        super(type, [RuntimeType.NUMBER], false, false, param);
+        this.interopNameConvertor = new InteropNameConvertor(createEmptyReferenceResolver());
+    }
+    convertorArg(param, writer) {
+        return param;
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, `write${this.interopNameConvertor.convert(this.idlType)}`, [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeString(`${deserializerName}.read${this.interopNameConvertor.convert(this.idlType)}()`));
+    }
+    nativeType() {
+        return this.idlType;
+    }
+    interopType() {
+        return this.idlType;
+    }
+    isPointerType() {
+        return false;
+    }
+}
+export class PointerConvertor extends BaseArgConvertor {
+    constructor(param) {
+        // check numericPrimitiveTypes.include(type)
+        super(idl.IDLPointerType, [RuntimeType.NUMBER, RuntimeType.OBJECT], false, false, param);
+    }
+    convertorArg(param, writer) {
+        return param;
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, `writePointer`, [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeString(`${deserializerName}.readPointer()`));
+    }
+    nativeType() {
+        return this.idlType;
+    }
+    interopType() {
+        return this.idlType;
+    }
+    isPointerType() {
+        return false;
+    }
+}
+export class BufferConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(idl.IDLBufferType, [RuntimeType.OBJECT], false, true, param);
+    }
+    convertorArg(param, _) {
+        return param;
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, "writeBuffer", [value]);
+    }
+    convertorDeserialize(_, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readBuffer()`), this.idlType, { optional: false }));
+    }
+    nativeType() {
+        return idl.IDLBufferType;
+    }
+    interopType() {
+        return idl.IDLBufferType;
+    }
+    isPointerType() {
+        return true;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return writer.instanceOf(this, value);
+    }
+}
+export class AggregateConvertor extends BaseArgConvertor {
+    constructor(library, param, type, decl) {
+        super(type, [RuntimeType.OBJECT], false, true, param);
+        this.library = library;
+        this.decl = decl;
+        this.members = [];
+        // this.aliasName = ts.isTypeAliasDeclaration(this.type.parent) ? identName(this.type.parent.name) : undefined
+        this.memberConvertors = decl
+            .properties
+            // .filter(ts.isPropertySignature)
+            .map((member, index) => {
+            this.members[index] = [member.name, member.isOptional];
+            return library.typeConvertor(param, member.type, member.isOptional);
+        });
+    }
+    convertorArg(param, writer) {
+        throw new Error("Do not use for aggregates");
+    }
+    convertorSerialize(param, value, printer) {
+        this.memberConvertors.forEach((it, index) => {
+            let memberName = this.members[index][0];
+            let memberAccess = `${value}.${memberName}`;
+            printer.writeStatement(printer.makeAssign(`${value}_${memberName}`, undefined, printer.makeString(memberAccess), true));
+            it.convertorSerialize(param, `${value}_${memberName}`, printer);
+        });
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const statements = [];
+        if (writer.language === Language.CPP) {
+            statements.push(writer.makeAssign(bufferName, this.idlType, undefined, true, false));
+        }
+        // TODO: Needs to be reworked DeserializerBase.readFunction properly
+        if (writer.language === Language.ARKTS
+            && this.memberConvertors.find(it => it instanceof FunctionConvertor)) {
+            return new BlockStatement([writer.makeThrowError("Not implemented yet")], false);
+        }
+        for (let i = 0; i < this.decl.properties.length; i++) {
+            const prop = this.decl.properties[i];
+            const propConvertor = this.memberConvertors[i];
+            statements.push(propConvertor.convertorDeserialize(`${bufferName}_${prop.name}_buf`, deserializerName, (expr) => {
+                if (writer.language === Language.CPP) {
+                    // prefix initialization for CPP, just easier. Waiting for easy work with nullables
+                    return writer.makeAssign(`${bufferName}.${writer.escapeKeyword(prop.name)}`, undefined, expr, false);
+                }
+                /**
+                 * todo: check UnionType name creation for union of unnamed nodes (isNamedNode() == false)
+                 */
+                const memberType = prop.isOptional
+                    ? idl.createUnionType([idl.IDLUndefinedType, prop.type], "$NOT TO BE PRINTED%")
+                    : prop.type;
+                return writer.makeAssign(`${bufferName}_${prop.name}`, memberType, expr, true, true);
+            }, writer));
+        }
+        if (writer.language === Language.CPP) {
+            statements.push(assigneer(writer.makeString(bufferName)));
+        }
+        else if (writer.language == Language.CJ) {
+            const resultExpression = writer.makeString(`${writer.getNodeName(this.idlType)}(${this.decl.properties.map(prop => `${bufferName}_${prop.name}`).join(", ")})`);
+            statements.push(assigneer(resultExpression));
+        }
+        else {
+            const resultExpression = this.makeAssigneeExpression(this.decl.properties.map(prop => {
+                return [prop.name, writer.makeString(`${bufferName}_${prop.name}`)];
+            }), writer);
+            statements.push(assigneer(resultExpression));
+        }
+        return new BlockStatement(statements, false);
+    }
+    makeAssigneeExpression(fields, writer) {
+        const content = fields.map(it => `${it[0]}: ${it[1].asString()}`).join(', ');
+        return writer.makeCast(writer.makeString(`{${content}}`), this.idlType);
+    }
+    nativeType() {
+        return idl.createReferenceType(this.decl.name, undefined, this.decl);
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+    getMembers() {
+        return this.members.map(it => it[0]);
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        const uniqueFields = this.members.filter(it => !duplicates.has(it[0]));
+        return this.discriminatorFromFields(value, writer, uniqueFields, it => it[0], it => it[1], duplicates);
+    }
+}
+export class TupleConvertor extends AggregateConvertor {
+    constructor(library, param, type, decl) {
+        super(library, param, type, decl);
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        this.memberConvertors.forEach((it, index) => {
+            printer.writeStatement(printer.makeAssign(`${value}_${index}`, undefined, printer.makeTupleAccess(value, index), true));
+            it.convertorSerialize(param, `${value}_${index}`, printer);
+        });
+    }
+    makeAssigneeExpression(fields, writer) {
+        return writer.makeCast(writer.makeString(`[${fields.map(it => it[1].asString()).join(', ')}]`), this.idlType);
+    }
+    nativeType() {
+        return idl.createReferenceType(this.decl.name, undefined, this.decl);
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+    getObjectAccessor(language, value, args) {
+        return (args === null || args === void 0 ? void 0 : args.index)
+            ? language === Language.CPP
+                ? `${value}.value${args.index}`
+                : `${value}[${args.index}]`
+            : value;
+    }
+}
+export class InterfaceConvertor extends BaseArgConvertor {
+    constructor(library, name /* change to IDLReferenceType */, param, declaration) {
+        super(idl.createReferenceType(name, undefined, declaration), [RuntimeType.OBJECT], false, true, param);
+        this.library = library;
+        this.declaration = declaration;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, `write${this.library.getInteropName(this.idlType)}`, [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeMethodCall(`${deserializerName}`, `read${this.library.getInteropName(this.idlType)}`, []));
+    }
+    nativeType() {
+        return this.idlType;
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+    getMembers() {
+        var _a, _b;
+        return (_b = (_a = this.declaration) === null || _a === void 0 ? void 0 : _a.properties.map(it => it.name)) !== null && _b !== void 0 ? _b : [];
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        var _a;
+        // Try to figure out interface by examining field sets
+        const uniqueFields = (_a = this.declaration) === null || _a === void 0 ? void 0 : _a.properties.filter(it => !duplicates.has(it.name));
+        return this.discriminatorFromFields(value, writer, uniqueFields, it => it.name, it => it.isOptional, duplicates);
+    }
+}
+export class ClassConvertor extends InterfaceConvertor {
+    constructor(library, name, param, declaration) {
+        super(library, name, param, declaration);
+    }
+    unionDiscriminator(value, index, writer, duplicateMembers) {
+        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.instanceOf(this, value, duplicateMembers)]);
+    }
+}
+export class ArrayConvertor extends BaseArgConvertor {
+    constructor(library, param, type, elementType) {
+        super(idl.createContainerType('sequence', [elementType]), [RuntimeType.OBJECT], false, true, param);
+        this.library = library;
+        this.type = type;
+        this.elementType = elementType;
+        this.elementConvertor = library.typeConvertor(param, elementType);
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        // Array length.
+        const valueLength = printer.makeArrayLength(value).asString();
+        const loopCounter = "i";
+        printer.writeMethodCall(`${param}Serializer`, "writeInt32", [printer.castToInt(valueLength, 32)]);
+        printer.writeStatement(printer.makeLoop(loopCounter, valueLength));
+        printer.pushIndent();
+        printer.writeStatement(printer.makeAssign(`${value}_element`, this.elementType, printer.makeArrayAccess(value, loopCounter), true));
+        this.elementConvertor.convertorSerialize(param, this.elementConvertor.getObjectAccessor(printer.language, `${value}_element`), printer);
+        printer.popIndent();
+        printer.print(`}`);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const lengthBuffer = `${bufferName}_length`;
+        const counterBuffer = `${bufferName}_i`;
+        const statements = [];
+        const arrayType = this.idlType;
+        statements.push(writer.makeAssign(lengthBuffer, idl.IDLI32Type, writer.makeString(`${deserializerName}.readInt32()`), true));
+        statements.push(writer.makeAssign(bufferName, arrayType, writer.makeArrayInit(this.type), true, false));
+        statements.push(writer.makeArrayResize(bufferName, writer.getNodeName(arrayType), lengthBuffer, deserializerName));
+        statements.push(writer.makeLoop(counterBuffer, lengthBuffer, this.elementConvertor.convertorDeserialize(`${bufferName}_buf`, deserializerName, (expr) => {
+            return writer.makeAssign(writer.makeArrayAccess(bufferName, counterBuffer).asString(), undefined, expr, false);
+        }, writer)));
+        statements.push(assigneer(writer.makeString(bufferName)));
+        return new BlockStatement(statements, false);
+    }
+    nativeType() {
+        return idl.createContainerType('sequence', [this.elementType]);
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.instanceOf(this, value, duplicates)]);
+    }
+    getObjectAccessor(language, value, args) {
+        const array = language === Language.CPP ? ".array" : "";
+        return (args === null || args === void 0 ? void 0 : args.index) ? `${value}${array}${args.index}` : value;
+    }
+}
+export class MapConvertor extends BaseArgConvertor {
+    constructor(library, param, type, keyType, valueType) {
+        super(idl.createContainerType('record', [keyType, valueType]), [RuntimeType.OBJECT], false, true, param);
+        this.library = library;
+        this.keyType = keyType;
+        this.valueType = valueType;
+        this.keyConvertor = library.typeConvertor(param, keyType);
+        this.valueConvertor = library.typeConvertor(param, valueType);
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        // Map size.
+        const mapSize = printer.makeMapSize(value);
+        printer.writeMethodCall(`${param}Serializer`, "writeInt32", [mapSize.asString()]);
+        printer.writeStatement(printer.makeMapForEach(value, `${value}_key`, `${value}_value`, () => {
+            this.keyConvertor.convertorSerialize(param, `${value}_key`, printer);
+            this.valueConvertor.convertorSerialize(param, `${value}_value`, printer);
+        }));
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const mapTypeName = writer.getNodeName(this.idlType);
+        const keyType = this.keyType;
+        const valueType = this.valueType;
+        const sizeBuffer = `${bufferName}_size`;
+        const keyBuffer = `${bufferName}_key`;
+        const valueBuffer = `${bufferName}_value`;
+        const counterBuffer = `${bufferName}_i`;
+        const keyAccessor = this.getObjectAccessor(writer.language, bufferName, { index: counterBuffer, field: "keys" });
+        const valueAccessor = this.getObjectAccessor(writer.language, bufferName, { index: counterBuffer, field: "values" });
+        return new BlockStatement([
+            writer.makeAssign(sizeBuffer, idl.IDLI32Type, writer.makeString(`${deserializerName}.readInt32()`), true, true),
+            writer.makeAssign(bufferName, this.idlType, writer.makeMapInit(this.idlType), true, false),
+            writer.makeMapResize(mapTypeName, keyType, valueType, bufferName, sizeBuffer, deserializerName),
+            writer.makeLoop(counterBuffer, sizeBuffer, new BlockStatement([
+                this.keyConvertor.convertorDeserialize(`${keyBuffer}_buf`, deserializerName, (expr) => {
+                    return writer.makeAssign(keyBuffer, keyType, expr, true, true);
+                }, writer),
+                this.valueConvertor.convertorDeserialize(`${valueBuffer}_buf`, deserializerName, (expr) => {
+                    return writer.makeAssign(valueBuffer, valueType, expr, true, true);
+                }, writer),
+                writer.makeMapInsert(keyAccessor, keyBuffer, valueAccessor, valueBuffer),
+            ], false)),
+            assigneer(writer.makeString(bufferName))
+        ], false);
+    }
+    nativeType() {
+        return idl.createContainerType('record', [this.keyType, this.valueType]);
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.makeString(`${value} instanceof Map`)]);
+    }
+    getObjectAccessor(language, value, args) {
+        return language === Language.CPP && (args === null || args === void 0 ? void 0 : args.index) && (args === null || args === void 0 ? void 0 : args.field)
+            ? `${value}.${args.field}[${args.index}]`
+            : value;
+    }
+}
+export class DateConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(idl.IDLBigintType, [RuntimeType.NUMBER], false, false, param);
+    }
+    convertorArg(param, writer) {
+        if (writer.language === Language.CPP) {
+            return param;
+        }
+        return `${param}.getTime()`;
+    }
+    convertorSerialize(param, value, writer) {
+        if (writer.language === Language.CPP) {
+            writer.writeMethodCall(`${param}Serializer`, "writeInt64", [value]);
+        }
+        else {
+            writer.writeMethodCall(`${param}Serializer`, "writeInt64", [
+                writer.makeCast(writer.makeString(`${value}.getTime()`), idl.IDLI64Type).asString()
+            ]);
+        }
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const deserializeTime = writer.makeMethodCall(`${deserializerName}`, "readInt64", []);
+        if (writer.language === Language.CPP) {
+            return assigneer(deserializeTime);
+        }
+        return assigneer(writer.makeString(`new Date(${deserializeTime.asString()})`));
+    }
+    nativeType() {
+        return idl.createReferenceType('Date');
+    }
+    interopType() {
+        return idl.IDLDate;
+    }
+    isPointerType() {
+        return false;
+    }
+}
+export class ProxyConvertor extends BaseArgConvertor {
+    constructor(convertor, suggestedName) {
+        super(suggestedName ? idl.createReferenceType(suggestedName, undefined, convertor.idlType) : convertor.idlType, convertor.runtimeTypes, convertor.isScoped, convertor.useArray, convertor.param);
+        this.convertor = convertor;
+    }
+    convertorArg(param, writer) {
+        return this.convertor.convertorArg(param, writer);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return this.convertor.convertorDeserialize(bufferName, deserializerName, assigneer, writer);
+    }
+    convertorSerialize(param, value, printer) {
+        this.convertor.convertorSerialize(param, value, printer);
+    }
+    nativeType() {
+        return this.convertor.nativeType();
+    }
+    interopType() {
+        return this.convertor.interopType();
+    }
+    isPointerType() {
+        return this.convertor.isPointerType();
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        return this.convertor.unionDiscriminator(value, index, writer, duplicates);
+    }
+    getMembers() {
+        return this.convertor.getMembers();
+    }
+}
+export class TypeAliasConvertor extends ProxyConvertor {
+    constructor(library, param, typedef) {
+        super(library.typeConvertor(param, typedef.type), typedef.name);
+    }
+}
+export class CustomTypeConvertor extends BaseArgConvertor {
+    constructor(param, customTypeName, isGenericType = false, tsType) {
+        super(idl.createReferenceType(tsType !== null && tsType !== void 0 ? tsType : "Object"), [RuntimeType.OBJECT], false, true, param);
+        this.customTypeName = customTypeName;
+        this.isGenericType = isGenericType;
+        warnCustomObject(`${tsType}`);
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    /** todo: check */
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, `writeCustomObject`, [`"${this.customTypeName}"`, printer.makeCastCustomObject(value, this.isGenericType).asString()]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const type = writer.language === Language.CPP
+            ? this.nativeType()
+            : this.idlType;
+        return assigneer(writer.makeCast(writer.makeMethodCall(`${deserializerName}`, "readCustomObject", [writer.makeString(`"${this.customTypeName}"`)]), type, { optional: false }));
+    }
+    nativeType() {
+        return idl.IDLCustomObjectType;
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+}
+export class OptionConvertor extends BaseArgConvertor {
+    // TODO: be smarter here, and for smth like Length|undefined or number|undefined pass without serializer.
+    constructor(library, param, type) {
+        let conv = library.typeConvertor(param, type);
+        let runtimeTypes = conv.runtimeTypes;
+        if (!runtimeTypes.includes(RuntimeType.UNDEFINED)) {
+            runtimeTypes.push(RuntimeType.UNDEFINED);
+        }
+        super(idl.createOptionalType(conv.idlType), runtimeTypes, conv.isScoped, true, param);
+        this.library = library;
+        this.type = type;
+        this.typeConvertor = conv;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        const valueType = `${value}_type`;
+        const serializedType = (printer.language == Language.JAVA ? undefined : idl.IDLI32Type);
+        printer.writeStatement(printer.makeAssign(valueType, serializedType, printer.makeRuntimeType(RuntimeType.UNDEFINED), true, false));
+        printer.runtimeType(this, valueType, value);
+        printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(valueType, 8)]);
+        printer.print(`if (${printer.makeRuntimeTypeCondition(valueType, false, RuntimeType.UNDEFINED, value).asString()}) {`);
+        printer.pushIndent();
+        printer.writeStatement(printer.makeAssign(`${value}_value`, undefined, printer.makeValueFromOption(value, this.typeConvertor), true));
+        this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, `${value}_value`), printer);
+        printer.popIndent();
+        printer.print(`}`);
+    }
+    convertorCArg(param) {
+        throw new Error("Must never be used");
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const runtimeBufferName = `${bufferName}_runtimeType`;
+        const statements = [];
+        statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
+        const bufferType = this.nativeType();
+        if (writer.language == Language.CJ) {
+            statements.push(writer.makeAssign(bufferName, bufferType, idl.isOptionalType(bufferType) ? writer.makeString('Option.None') : undefined, true, false));
+        }
+        else {
+            statements.push(writer.makeAssign(bufferName, bufferType, undefined, true, false));
+        }
+        const thenStatement = new BlockStatement([
+            this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
+                const receiver = writer.language === Language.CPP
+                    ? `${bufferName}.value` : bufferName;
+                return writer.makeAssign(receiver, undefined, expr, false);
+            }, writer)
+        ]);
+        statements.push(writer.makeSetOptionTag(bufferName, writer.makeCast(writer.makeString(runtimeBufferName), writer.getTagType())));
+        statements.push(writer.makeCondition(writer.makeRuntimeTypeDefinedCheck(runtimeBufferName), thenStatement));
+        statements.push(assigneer(writer.makeString(bufferName)));
+        return writer.makeBlock(statements, false);
+    }
+    nativeType() {
+        return idl.createOptionalType(this.type);
+    }
+    interopType() {
+        return idl.createOptionalType(this.type);
+    }
+    isPointerType() {
+        return true;
+    }
+    getObjectAccessor(language, value, args) {
+        return language === Language.CPP ? `${value}.value` : value;
+    }
+}
+export class UnionConvertor extends BaseArgConvertor {
+    constructor(library, param, type) {
+        super(idl.IDLObjectType, [], false, true, param);
+        this.library = library;
+        this.type = type;
+        this.memberConvertors = type.types.map(member => library.typeConvertor(param, member));
+        this.unionChecker = new UnionRuntimeTypeChecker(this.memberConvertors);
+        this.runtimeTypes = this.memberConvertors.flatMap(it => it.runtimeTypes);
+        this.idlType = type;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Do not use for union");
+    }
+    convertorSerialize(param, value, printer) {
+        var _a;
+        printer.writeStatement(printer.makeAssign(`${value}_type`, idl.IDLI32Type, printer.makeUnionTypeDefaultInitializer(), true, false));
+        printer.writeStatement(printer.makeUnionSelector(value, `${value}_type`));
+        this.memberConvertors.forEach((it, index) => {
+            const maybeElse = (index > 0 && this.memberConvertors[index - 1].runtimeTypes.length > 0) ? "else " : "";
+            const conditions = this.unionChecker.makeDiscriminator(value, index, printer);
+            printer.print(`${maybeElse}if (${conditions.asString()}) {`);
+            printer.pushIndent();
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(index.toString(), 8)]);
+            if (!(it instanceof UndefinedConvertor)) {
+                printer.writeStatement(printer.makeAssign(`${value}_${index}`, undefined, printer.makeUnionVariantCast(it.getObjectAccessor(printer.language, value), printer.getNodeName(it.idlType), it, index), true));
+                it.convertorSerialize(param, `${value}_${index}`, printer);
+            }
+            printer.popIndent();
+            printer.print(`}`);
+        });
+        this.unionChecker.reportConflicts((_a = this.library.getCurrentContext()) !== null && _a !== void 0 ? _a : "<unknown context>");
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const statements = [];
+        let selectorBuffer = `${bufferName}_selector`;
+        const maybeOptionalUnion = writer.language === Language.CPP || writer.language == Language.CJ
+            ? this.type
+            : idl.createOptionalType(this.type);
+        statements.push(writer.makeAssign(selectorBuffer, idl.IDLI8Type, writer.makeString(`${deserializerName}.readInt8()`), true));
+        statements.push(writer.makeAssign(bufferName, maybeOptionalUnion, undefined, true, false));
+        if (writer.language === Language.CPP)
+            statements.push(writer.makeAssign(`${bufferName}.selector`, undefined, writer.makeString(selectorBuffer), false));
+        const branches = this.memberConvertors.map((it, index) => {
+            const receiver = this.getObjectAccessor(writer.language, bufferName, { index: `${index}` });
+            const expr = writer.makeString(`${selectorBuffer} == ${index}`);
+            const stmt = new BlockStatement([
+                writer.makeSetUnionSelector(bufferName, `${index}`),
+                it.convertorDeserialize(`${bufferName}_u`, deserializerName, (expr) => {
+                    if (writer.language == Language.CJ) {
+                        return writer.makeAssign(receiver, undefined, writer.makeFunctionCall(writer.getNodeName(this.type), [expr]), false);
+                    }
+                    else {
+                        return writer.makeAssign(receiver, undefined, expr, false);
+                    }
+                }, writer),
+            ], false);
+            return { expr, stmt };
+        });
+        statements.push(writer.makeMultiBranchCondition(branches, writer.makeThrowError(`One of the branches for ${bufferName} has to be chosen through deserialisation.`)));
+        statements.push(assigneer(writer.makeCast(writer.makeString(bufferName), this.type)));
+        return new BlockStatement(statements, false);
+    }
+    nativeType() {
+        return this.type;
+    }
+    interopType() {
+        throw new Error("Union");
+    }
+    isPointerType() {
+        return true;
+    }
+    getObjectAccessor(language, value, args) {
+        return language === Language.CPP && (args === null || args === void 0 ? void 0 : args.index) ? `${value}.value${args.index}` : value;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        const checker = new UnionRuntimeTypeChecker(this.memberConvertors);
+        return writer.makeNaryOp("||", this.memberConvertors.map((_, n) => checker.makeDiscriminator(value, n, writer)));
+    }
+}
+export class FunctionConvertor extends BaseArgConvertor {
+    constructor(library, param, type) {
+        // TODO: pass functions as integers to native side.
+        super(idl.IDLFunctionType, [RuntimeType.FUNCTION], false, false, param);
+        this.library = library;
+        this.type = type;
+    }
+    convertorArg(param, writer) {
+        return writer.language == Language.CPP ? `makeArkFunctionFromId(${param})` : `registerCallback(${param})`;
+    }
+    convertorSerialize(param, value, writer) {
+        writer.writeMethodCall(`${param}Serializer`, "writeFunction", [value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readFunction()`), this.type, { optional: true }));
+    }
+    nativeType() {
+        return idl.IDLFunctionType;
+    }
+    interopType() {
+        return idl.IDLFunctionType;
+    }
+    isPointerType() {
+        return false;
+    }
+}
+export class MaterializedClassConvertor extends BaseArgConvertor {
+    constructor(param, declaration) {
+        super(idl.createReferenceType(declaration.name, undefined, declaration), [RuntimeType.OBJECT], false, true, param);
+        this.declaration = declaration;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeStatement(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `write${this.declaration.name}`, [
+            printer.makeString(value)
+        ])));
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        const readStatement = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `read${this.declaration.name}`, []), idl.createReferenceType(this.declaration.name, undefined, this.declaration));
+        return assigneer(readStatement);
+    }
+    nativeType() {
+        return idl.createReferenceType(this.declaration.name, undefined, this.declaration);
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+    unionDiscriminator(value, index, writer, duplicates) {
+        if (idl.isInterface(this.declaration)) {
+            if (this.declaration.subkind === idl.IDLInterfaceSubkind.Class) {
+                return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.instanceOf(this, value, duplicates)]);
+            }
+            if (this.declaration.subkind === idl.IDLInterfaceSubkind.Interface) {
+                const uniqueFields = this.declaration.properties.filter(it => !duplicates.has(it.name));
+                return this.discriminatorFromFields(value, writer, uniqueFields, it => it.name, it => it.isOptional, duplicates);
+            }
+        }
+    }
+}
+export class ImportTypeConvertor extends BaseArgConvertor {
+    constructor(param, importedName) {
+        super(idl.IDLObjectType, [RuntimeType.OBJECT], false, true, param);
+        this.importedName = importedName;
+        warnCustomObject(importedName, `imported`);
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, printer) {
+        printer.writeMethodCall(`${param}Serializer`, "writeCustomObject", [`"${this.importedName}"`, value]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeString(`${deserializerName}.readCustomObject("${this.importedName}")`));
+    }
+    nativeType() {
+        // treat ImportType as CustomObject
+        return idl.IDLCustomObjectType;
+    }
+    interopType() {
+        throw new Error("Must never be used");
+    }
+    isPointerType() {
+        return true;
+    }
+}
+export class CallbackConvertor extends BaseArgConvertor {
+    constructor(library, param, decl) {
+        super(idl.createReferenceType(decl.name, undefined, decl), [RuntimeType.FUNCTION], false, true, param);
+        this.library = library;
+        this.decl = decl;
+    }
+    get isTransformed() {
+        return this.decl !== this.transformedDecl;
+    }
+    get transformedDecl() {
+        var _a;
+        return (_a = maybeTransformManagedCallback(this.decl)) !== null && _a !== void 0 ? _a : this.decl;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Must never be used");
+    }
+    convertorSerialize(param, value, writer) {
+        if (writer.language == Language.CPP) {
+            writer.writeMethodCall(`${param}Serializer`, "writeCallbackResource", [`${value}.resource`]);
+            writer.writeMethodCall(`${param}Serializer`, "writePointer", [writer.makeCast(new StringExpression(`${value}.call`), idl.IDLPointerType, { unsafe: true }).asString()]);
+            writer.writeMethodCall(`${param}Serializer`, "writePointer", [writer.makeCast(new StringExpression(`${value}.callSync`), idl.IDLPointerType, { unsafe: true }).asString()]);
+            return;
+        }
+        if (this.isTransformed)
+            value = `CallbackTransformer.transformFrom${this.library.getInteropName(this.decl)}(${value})`;
+        writer.writeMethodCall(`${param}Serializer`, `holdAndWriteCallback`, [`${value}`]);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer, useSyncVersion = false) {
+        if (writer.language == Language.CPP) {
+            const callerInvocation = writer.makeString(`getManagedCallbackCaller(${generateCallbackKindAccess(this.transformedDecl, writer.language)})`);
+            const callerSyncInvocation = writer.makeString(`getManagedCallbackCallerSync(${generateCallbackKindAccess(this.transformedDecl, writer.language)})`);
+            const resourceReadExpr = writer.makeMethodCall(`${deserializerName}`, `readCallbackResource`, []);
+            const callReadExpr = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `readPointerOrDefault`, [writer.makeCast(callerInvocation, idl.IDLPointerType, { unsafe: true })]), idl.IDLUndefinedType /* not used */, {
+                unsafe: true,
+                overrideTypeName: `void(*)(${generateCallbackAPIArguments(this.library, this.transformedDecl).join(", ")})`
+            });
+            const callSyncReadExpr = writer.makeCast(writer.makeMethodCall(`${deserializerName}`, `readPointerOrDefault`, [writer.makeCast(callerSyncInvocation, idl.IDLPointerType, { unsafe: true })]), idl.IDLUndefinedType /* not used */, {
+                unsafe: true,
+                overrideTypeName: `void(*)(${[`${generatorTypePrefix()}VMContext vmContext`].concat(generateCallbackAPIArguments(this.library, this.transformedDecl)).join(", ")})`
+            });
+            return assigneer(writer.makeString(`{${resourceReadExpr.asString()}, ${callReadExpr.asString()}, ${callSyncReadExpr.asString()}}`));
+        }
+        let result = writer.makeString(`${deserializerName}.read${this.library.getInteropName(this.transformedDecl)}(${useSyncVersion ? 'true' : ''})`);
+        if (this.isTransformed)
+            result = writer.makeMethodCall(`CallbackTransformer`, `transformTo${this.library.getInteropName(this.decl)}`, [result]);
+        return assigneer(result);
+    }
+    nativeType() {
+        return idl.createReferenceType(this.transformedDecl.name, undefined, this.decl);
+    }
+    isPointerType() {
+        return true;
+    }
+}
+////////////////////////////////////////////////////////////////////////////////
+// UTILS
+const customObjects = new Set();
+function warnCustomObject(type, msg) {
+    if (!customObjects.has(type)) {
+        warn(`Use CustomObject for ${msg ? `${msg} ` : ``}type ${type}`);
+        customObjects.add(type);
+    }
+}
+export const CallbackKind = "CallbackKind";
+export function generateCallbackKindName(callback) {
+    return `Kind_${callback.name}`;
+}
+export function generateCallbackKindAccess(callback, language) {
+    const name = generateCallbackKindName(callback);
+    if (language == Language.CPP)
+        return name;
+    return `${CallbackKind}.${name}`;
+}
+export function generateCallbackKindValue(callback) {
+    const name = generateCallbackKindName(callback);
+    return hashCodeFromString(name);
+}
+export function generateCallbackAPIArguments(library, callback) {
+    const nameConvertor = new CppInteropConvertor(library);
+    const args = [`const ${PrimitiveTypesInstance.Int32.getText()} resourceId`];
+    args.push(...callback.parameters.map(it => {
+        const target = library.toDeclaration(it.type);
+        const type = library.typeConvertor(it.name, it.type, it.isOptional);
+        const constPrefix = !idl.isEnum(target) ? "const " : "";
+        return `${constPrefix}${nameConvertor.convert(type.nativeType())} ${type.param}`;
+    }));
+    if (!idl.isVoidType(callback.returnType)) {
+        const type = library.typeConvertor(`continuation`, library.createContinuationCallbackReference(callback.returnType), false);
+        args.push(`const ${nameConvertor.convert(type.nativeType())} ${type.param}`);
+    }
+    return args;
+}
+export function maybeTransformManagedCallback(callback) {
+    if (callback.name === "CustomBuilder")
+        return idl.createCallback("CustomNodeBuilder", [idl.createParameter("parentNode", idl.IDLPointerType)], idl.IDLPointerType, { extendedAttributes: [{ name: idl.IDLExtendedAttributes.Synthetic }] });
+    return undefined;
+}
+//# sourceMappingURL=ArgConvertors.js.map