@idlizer/core 2.1.9-arktscgen-6 → 2.1.9-arktscgen-9

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

@@ -17,7 +17,7 @@ import { Language } from "../Language";
 import { BlockStatement, PrintHint, StringExpression, MethodModifier, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorConfiguration, generatorTypePrefix } from "../config";
-import { getExtractorName, hashCodeFromString, warn } from "../util";
+import { capitalize, getExtractor, hashCodeFromString, throwException, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
@@ -25,6 +25,7 @@ import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { qualifiedName } from "../peer-generation/idl/common";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
 import { PeerMethodSignature } from "../peer-generation/PeerMethod";
+import { isInExternalModule } from "../peer-generation/modules";
 export function getSerializerName(declaration) {
     return `${idl.getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
 }
@@ -122,13 +123,12 @@ export class BaseArgConvertor {
             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) {
+    discriminatorFromFields(value, writer, uniqueFields, nameAccessor, optionalAccessor) {
         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)
-        ]);
+        const accessors = firstNonOptional ? [nameAccessor(firstNonOptional)] : uniqueFields.map(it => nameAccessor(it));
+        return writer.makeNaryOp("||", accessors.map(it => writer.makeHasOwnProperty(value + "!", it)));
     }
 }
 export class BooleanConvertor extends BaseArgConvertor {
@@ -139,7 +139,7 @@ export class BooleanConvertor extends BaseArgConvertor {
         return writer.castToBoolean(param);
     }
     convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, "writeBoolean", [value]);
+        return printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeBoolean", [printer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeString(`${deserializerName}.readBoolean()`));
@@ -161,7 +161,9 @@ export class UndefinedConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return writer.makeUndefined().asString();
     }
-    convertorSerialize(param, value, printer) { }
+    convertorSerialize(param, value, printer) {
+        return printer.makeStatement(printer.makeString(""));
+    }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeUndefined());
     }
@@ -196,7 +198,7 @@ export class StringConvertor extends BaseArgConvertor {
             : writer.escapeKeyword(param);
     }
     convertorSerialize(param, value, writer) {
-        writer.writeMethodCall(`${param}Serializer`, `writeString`, [value]);
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writeString", [writer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readString()`), this.idlType, { optional: false }));
@@ -231,7 +233,7 @@ export class EnumConvertor extends BaseArgConvertor {
         return writer.i32FromEnum(writer.makeString(writer.escapeKeyword(param)), this.enumEntry).asString();
     }
     convertorSerialize(param, value, writer) {
-        writer.writeMethodCall(`${param}Serializer`, "writeInt32", [writer.i32FromEnum(writer.makeString(value), this.enumEntry).asString()]);
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writeInt32", [writer.i32FromEnum(writer.makeString(value), this.enumEntry)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const readExpr = writer.makeMethodCall(`${deserializerName}`, "readInt32", []);
@@ -251,7 +253,21 @@ export class EnumConvertor extends BaseArgConvertor {
         return writer.getNodeName(this.idlType); // this.enumTypeName(writer.language)
     }
     unionDiscriminator(value, index, writer, duplicates) {
-        return writer.makeDiscriminatorConvertor(this, value, index);
+        const convertorNativeType = this.nativeType();
+        const decl = writer.resolver.resolveTypeReference(idl.isReferenceType(convertorNativeType)
+            ? convertorNativeType
+            : idl.createReferenceType(this.targetType(writer)));
+        if (decl === undefined || !idl.isEnum(decl)) {
+            throwException(`The type reference ${decl === null || decl === void 0 ? void 0 : decl.name} must be Enum`);
+        }
+        const ordinal = idl.isStringEnum(decl)
+            ? writer.i32FromEnum(writer.makeCast(writer.makeString(writer.getObjectAccessor(this, value)), this.idlType), decl)
+            : writer.makeUnionVariantCast(writer.getObjectAccessor(this, value), writer.getNodeName(idl.IDLI32Type), this, index);
+        const { low, high } = idl.extremumOfOrdinals(decl);
+        return writer.makeNaryOp("&&", [
+            writer.makeNaryOp(">=", [ordinal, writer.makeString(low.toString())]),
+            writer.makeNaryOp("<=", [ordinal, writer.makeString(high.toString())])
+        ]);
     }
 }
 export class NumberConvertor extends BaseArgConvertor {
@@ -265,8 +281,8 @@ export class NumberConvertor extends BaseArgConvertor {
             ? writer.makeUnsafeCast_(writer.makeString(`&${param}`), this.idlType, PrintHint.AsConstPointer)
             : writer.escapeKeyword(param);
     }
-    convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, "writeNumber", [value]);
+    convertorSerialize(param, value, writer) {
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writeNumber", [writer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readNumber()`), this.idlType, { optional: false }));
@@ -290,8 +306,8 @@ export class NumericConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return param;
     }
-    convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, `write${this.interopNameConvertor.convert(this.idlType)}`, [value]);
+    convertorSerialize(param, value, writer) {
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `write${this.interopNameConvertor.convert(this.idlType)}`, [writer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeString(`${deserializerName}.read${this.interopNameConvertor.convert(this.idlType)}()`));
@@ -313,8 +329,8 @@ export class BigIntToU64Convertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return writer.escapeKeyword(param);
     }
-    convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, "writeInt64", [value]);
+    convertorSerialize(param, value, writer) {
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `writeInt64`, [writer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readInt64()`), this.idlType, { optional: false }));
@@ -345,13 +361,8 @@ export class ObjectConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return writer.escapeKeyword(param);
     }
-    convertorSerialize(param, value, printer) {
-        if (printer.language === Language.CPP) {
-            printer.writeMethodCall(`${param}Serializer`, "writeObject", [value]);
-        }
-        else {
-            printer.writeMethodCall(`${param}Serializer`, "holdAndWriteObject", [value]);
-        }
+    convertorSerialize(param, value, writer) {
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, writer.language === Language.CPP ? `writeObject` : "holdAndWriteObject", [writer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeCast(writer.makeMethodCall(deserializerName, 'readObject', []), this.idlType, { optional: false }));
@@ -380,8 +391,8 @@ export class PointerConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return param;
     }
-    convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, `writePointer`, [value]);
+    convertorSerialize(param, value, writer) {
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writePointer", [writer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeString(`${deserializerName}.readPointer()`));
@@ -403,8 +414,8 @@ export class BufferConvertor extends BaseArgConvertor {
     convertorArg(param, _) {
         return param;
     }
-    convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, "writeBuffer", [value]);
+    convertorSerialize(param, value, writer) {
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writeBuffer", [writer.makeString(value)]));
     }
     convertorDeserialize(_, deserializerName, assigneer, writer) {
         return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readBuffer()`), this.idlType, { optional: false }));
@@ -419,7 +430,7 @@ export class BufferConvertor extends BaseArgConvertor {
         return true;
     }
     unionDiscriminator(value, index, writer, duplicates) {
-        return writer.instanceOf(this, value);
+        return writer.instanceOf(value, this.idlType);
     }
 }
 export class AggregateConvertor extends BaseArgConvertor {
@@ -441,12 +452,16 @@ export class AggregateConvertor extends BaseArgConvertor {
         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}.${printer.escapeKeyword(memberName)}`;
-            printer.writeStatement(printer.makeAssign(`${value}_${memberName}`, undefined, printer.makeString(memberAccess), true));
-            it.convertorSerialize(param, `${value}_${memberName}`, printer);
+        const stmts = this.memberConvertors.flatMap((it, index) => {
+            const memberName = this.members[index][0];
+            const memberAccess = `${value}.${printer.escapeKeyword(memberName)}`;
+            const memberMangledName = `${value}${capitalize(memberName)}`;
+            return [
+                printer.makeAssign(memberMangledName, undefined, printer.makeString(memberAccess), true),
+                it.convertorSerialize(param, memberMangledName, printer)
+            ];
         });
+        return printer.makeBlock(stmts, false);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const statements = [];
@@ -461,7 +476,8 @@ export class AggregateConvertor extends BaseArgConvertor {
         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) => {
+            const propName = `${bufferName}${capitalize(prop.name)}`;
+            statements.push(propConvertor.convertorDeserialize(`${propName}TempBuf`, 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);
@@ -470,7 +486,7 @@ export class AggregateConvertor extends BaseArgConvertor {
                  * todo: check UnionType name creation for union of unnamed nodes (isNamedNode() == false)
                  */
                 const memberType = idl.maybeOptional(prop.type, prop.isOptional);
-                return writer.makeAssign(`${bufferName}_${prop.name}`, memberType, expr, true, true);
+                return writer.makeAssign(propName, memberType, expr, true, true);
             }, writer));
         }
         if (writer.language === Language.CPP) {
@@ -480,9 +496,15 @@ export class AggregateConvertor extends BaseArgConvertor {
             const resultExpression = writer.makeString(`${writer.getNodeName(this.idlType)}(${this.decl.properties.map(prop => `${bufferName}_${prop.name}`).join(", ")})`);
             statements.push(assigneer(resultExpression));
         }
+        else if (writer.language == Language.KOTLIN) {
+            const resultExpression = this.decl.subkind === idl.IDLInterfaceSubkind.Tuple ?
+                writer.makeString(`${writer.getNodeName(this.idlType)}(${this.decl.properties.map(prop => `${bufferName}_${prop.name}`).join(', ')})`) :
+                writer.makeString(`object: ${writer.getNodeName(this.idlType)} { ${this.decl.properties.map(prop => `override var ${prop.name} = ${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}`)];
+                return [prop.name, writer.makeString(`${bufferName}${capitalize(prop.name)}`)];
             }), writer);
             statements.push(assigneer(resultExpression));
         }
@@ -506,7 +528,7 @@ export class AggregateConvertor extends BaseArgConvertor {
     }
     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);
+        return this.discriminatorFromFields(value, writer, uniqueFields, it => it[0], it => it[1]);
     }
 }
 export class TupleConvertor extends AggregateConvertor {
@@ -517,10 +539,13 @@ export class TupleConvertor extends AggregateConvertor {
         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);
+        const stmts = this.memberConvertors.flatMap((it, index) => {
+            return [
+                printer.makeAssign(`${value}_${index}`, undefined, printer.makeTupleAccess(value, index), true),
+                it.convertorSerialize(param, `${value}_${index}`, printer)
+            ];
         });
+        return printer.makeBlock(stmts, false);
     }
     makeAssigneeExpression(fields, writer) {
         return writer.makeCast(writer.makeString(`[${fields.map(it => it[1].asString()).join(', ')}]`), this.idlType);
@@ -551,10 +576,10 @@ export class InterfaceConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         throw new Error("Must never be used");
     }
-    convertorSerialize(param, value, printer) {
+    convertorSerialize(param, value, writer) {
         const accessor = getSerializerName(this.declaration);
-        printer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        printer.writeStaticMethodCall(accessor, 'write', [`${param}Serializer`, value]);
+        writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
+        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const accessor = getSerializerName(this.declaration);
@@ -580,7 +605,7 @@ export class InterfaceConvertor extends BaseArgConvertor {
         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);
+        return this.discriminatorFromFields(value, writer, uniqueFields, it => it.name, it => it.isOptional);
     }
 }
 export class ClassConvertor extends InterfaceConvertor {
@@ -588,7 +613,7 @@ export class ClassConvertor extends InterfaceConvertor {
         super(library, name, param, declaration);
     }
     unionDiscriminator(value, index, writer, duplicateMembers) {
-        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.instanceOf(this, value, duplicateMembers)]);
+        return writer.instanceOf(value, this.idlType);
     }
 }
 export class ArrayConvertor extends BaseArgConvertor {
@@ -603,26 +628,27 @@ export class ArrayConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, printer) {
+        const statements = [];
         // 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, `${value}_element`, printer);
-        printer.popIndent();
-        printer.print(`}`);
+        statements.push(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt32", [printer.makeString(printer.castToInt(valueLength, 32))])));
+        const loopCounter = `${value}CounterI`;
+        const elementName = `${value}TmpElement`;
+        statements.push(printer.makeLoop(loopCounter, valueLength, printer.makeBlock([
+            printer.makeAssign(elementName, this.elementType, printer.makeArrayAccess(value, loopCounter), true),
+            this.elementConvertor.convertorSerialize(param, elementName, printer)
+        ], false)));
+        return printer.makeBlock(statements, false);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const lengthBuffer = `${bufferName}_length`;
-        const counterBuffer = `${bufferName}_i`;
+        const lengthBuffer = `${bufferName}Length`;
+        const counterBuffer = `${bufferName}BufCounterI`;
         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, lengthBuffer), 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) => {
+        statements.push(writer.makeLoop(counterBuffer, lengthBuffer, this.elementConvertor.convertorDeserialize(`${bufferName}TempBuf`, deserializerName, (expr) => {
             return writer.makeAssign(writer.makeArrayAccess(bufferName, counterBuffer).asString(), undefined, expr, false);
         }, writer)));
         statements.push(assigneer(writer.makeString(bufferName)));
@@ -638,7 +664,7 @@ export class ArrayConvertor extends BaseArgConvertor {
         return true;
     }
     unionDiscriminator(value, index, writer, duplicates) {
-        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.instanceOf(this, value, duplicates)]);
+        return writer.instanceOf(value, this.idlType);
     }
     getObjectAccessor(language, value, args) {
         const array = language === Language.CPP ? ".array" : "";
@@ -660,20 +686,22 @@ export class MapConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, printer) {
         // Map size.
         const mapSize = printer.makeMapSize(value);
-        printer.writeMethodCall(`${param}Serializer`, "writeInt32", [printer.castToInt(mapSize.asString(), 32)]);
-        printer.writeStatement(printer.makeMapForEach(value, `${value}_key`, `${value}_value`, () => {
-            this.keyConvertor.convertorSerialize(param, `${value}_key`, printer);
-            this.valueConvertor.convertorSerialize(param, `${value}_value`, printer);
-        }));
+        return printer.makeBlock([
+            printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt32", [printer.makeString(printer.castToInt(mapSize.asString(), 32))])),
+            printer.makeMapForEach(value, `${value}KeyVar`, `${value}ValueVar`, [
+                this.keyConvertor.convertorSerialize(param, `${value}KeyVar`, printer),
+                this.valueConvertor.convertorSerialize(param, `${value}ValueVar`, printer)
+            ])
+        ], false);
     }
     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 sizeBuffer = `${bufferName}SizeVar`;
+        const keyBuffer = `${bufferName}KeyVar`;
+        const valueBuffer = `${bufferName}ValueVar`;
+        const counterBuffer = `${bufferName}IVar`;
         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([
@@ -681,10 +709,10 @@ export class MapConvertor extends BaseArgConvertor {
             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) => {
+                this.keyConvertor.convertorDeserialize(`${keyBuffer}TempBuf`, deserializerName, (expr) => {
                     return writer.makeAssign(keyBuffer, keyType, expr, true, true);
                 }, writer),
-                this.valueConvertor.convertorDeserialize(`${valueBuffer}_buf`, deserializerName, (expr) => {
+                this.valueConvertor.convertorDeserialize(`${valueBuffer}TempBuf`, deserializerName, (expr) => {
                     return writer.makeAssign(valueBuffer, valueType, expr, true, true);
                 }, writer),
                 writer.makeMapInsert(keyAccessor, keyBuffer, valueAccessor, valueBuffer),
@@ -702,7 +730,7 @@ export class MapConvertor extends BaseArgConvertor {
         return true;
     }
     unionDiscriminator(value, index, writer, duplicates) {
-        return writer.discriminatorFromExpressions(value, RuntimeType.OBJECT, [writer.makeString(`${value} instanceof Map`)]);
+        return 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)
@@ -712,7 +740,7 @@ export class MapConvertor extends BaseArgConvertor {
 }
 export class DateConvertor extends BaseArgConvertor {
     constructor(param) {
-        super(idl.IDLBigintType, [RuntimeType.NUMBER], false, false, param);
+        super(idl.IDLDate, [RuntimeType.NUMBER], false, false, param);
     }
     convertorArg(param, writer) {
         if (writer.language === Language.CPP) {
@@ -722,17 +750,17 @@ export class DateConvertor extends BaseArgConvertor {
     }
     convertorSerialize(param, value, writer) {
         if (writer.language === Language.CPP) {
-            writer.writeMethodCall(`${param}Serializer`, "writeInt64", [value]);
+            return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writeInt64", [writer.makeString(value)]));
         }
         else if (writer.language === Language.CJ) {
-            writer.writeMethodCall(`${param}Serializer`, "writeInt64", [
-                writer.makeCast(writer.makeString(`${value}`), idl.IDLI64Type).asString()
-            ]);
+            return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writeInt64", [
+                writer.makeCast(writer.makeString(`${value}`), idl.IDLI64Type)
+            ]));
         }
         else {
-            writer.writeMethodCall(`${param}Serializer`, "writeInt64", [
-                writer.makeCast(writer.makeString(`${value}.getTime()`), idl.IDLI64Type).asString()
-            ]);
+            return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writeInt64", [
+                writer.makeCast(writer.makeString(`${value}.getTime()`), idl.IDLI64Type)
+            ]));
         }
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
@@ -767,7 +795,7 @@ export class ProxyConvertor extends BaseArgConvertor {
         return this.convertor.convertorDeserialize(bufferName, deserializerName, assigneer, writer);
     }
     convertorSerialize(param, value, printer) {
-        this.convertor.convertorSerialize(param, value, printer);
+        return this.convertor.convertorSerialize(param, value, printer);
     }
     nativeType() {
         return this.convertor.nativeType();
@@ -802,7 +830,7 @@ export class CustomTypeConvertor extends BaseArgConvertor {
     }
     /** todo: check */
     convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, `writeCustomObject`, [`"${this.customTypeName}"`, printer.makeCastCustomObject(value, this.isGenericType).asString()]);
+        return printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, `writeCustomObject`, [printer.makeString(`"${this.customTypeName}"`), printer.makeCastCustomObject(value, this.isGenericType)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const type = writer.language === Language.CPP
@@ -843,30 +871,12 @@ export class OptionConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, printer) {
-        const valueType = `${value}_type`.replaceAll('.', '_');
-        const serializedType = (printer.language == Language.JAVA ? undefined : idl.IDLI32Type);
-        printer.writeStatement(printer.makeAssign(valueType, serializedType, printer.makeRuntimeType(RuntimeType.UNDEFINED), true, false));
-        if (printer.language != Language.CJ && printer.language != Language.KOTLIN) {
-            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();
-        if (printer.language == Language.CJ || printer.language == Language.KOTLIN) {
-            printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.OBJECT.ordinal"]); // everything is object, except None<T>
-        }
-        const valueValue = `${value}_value`.replaceAll('.', '_');
-        printer.writeStatement(printer.makeAssign(valueValue, undefined, printer.makeValueFromOption(value, this.typeConvertor), true));
-        this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, valueValue), printer);
-        printer.popIndent();
-        printer.print(`}`);
-        if (printer.language == Language.CJ || printer.language == Language.KOTLIN) {
-            printer.print('else {');
-            printer.pushIndent();
-            printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.UNDEFINED.ordinal"]); // undefined
-            printer.popIndent();
-            printer.print('}');
-        }
+        const valueValue = `${value}TmpValue`.replaceAll('.', '_');
+        return printer.makeCondition(printer.makeDefinedCheck(value), new BlockStatement([
+            printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeRuntimeType(RuntimeType.OBJECT)])),
+            printer.makeAssign(valueValue, undefined, printer.makeValueFromOption(value, this.typeConvertor), true),
+            this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, valueValue), printer)
+        ], true, false), new BlockStatement([printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeRuntimeType(RuntimeType.UNDEFINED)]))], true, false));
     }
     convertorCArg(param) {
         throw new Error("Must never be used");
@@ -883,7 +893,7 @@ export class OptionConvertor extends BaseArgConvertor {
                     ? `${bufferName}.value` : bufferName;
                 return writer.makeAssign(receiver, undefined, expr, false);
             }, writer)
-        ]);
+        ], true, false);
         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)));
@@ -916,27 +926,23 @@ export class UnionConvertor extends BaseArgConvertor {
         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)]);
+        const branches = this.memberConvertors.map((it, index) => {
+            const discriminator = this.unionChecker.makeDiscriminator(value, index, printer);
+            const statements = [];
+            statements.push(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeString(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);
+                const varName = `${value}ForIdx${index}`;
+                statements.push(printer.makeAssign(varName, undefined, printer.makeUnionVariantCast(it.getObjectAccessor(printer.language, value), printer.getNodeName(it.idlType), it, index), true));
+                statements.push(it.convertorSerialize(param, varName, printer));
             }
-            printer.popIndent();
-            printer.print(`}`);
+            const stmt = new BlockStatement(statements, false);
+            return { expr: discriminator, stmt };
         });
-        this.unionChecker.reportConflicts((_a = this.library.getCurrentContext()) !== null && _a !== void 0 ? _a : "<unknown context>", printer);
+        return printer.makeMultiBranchCondition(branches);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const statements = [];
-        let selectorBuffer = `${bufferName}_selector`;
+        let selectorBuffer = `${bufferName}UnionSelector`;
         const maybeOptionalUnion = writer.language === Language.CPP || writer.language == Language.CJ
             ? this.type
             : idl.createOptionalType(this.type);
@@ -949,8 +955,8 @@ export class UnionConvertor extends BaseArgConvertor {
             const expr = writer.makeString(`${selectorBuffer} == ${writer.castToInt(index.toString(), 8)}`);
             const stmt = new BlockStatement([
                 writer.makeSetUnionSelector(bufferName, `${index}`),
-                it.convertorDeserialize(`${bufferName}_u`, deserializerName, (expr) => {
-                    if (writer.language == Language.CJ) {
+                it.convertorDeserialize(`${bufferName}BufU`, deserializerName, (expr) => {
+                    if (writer.language == Language.CJ || writer.language == Language.KOTLIN) {
                         return writer.makeAssign(receiver, undefined, writer.makeFunctionCall(writer.getNodeName(this.type), [expr]), false);
                     }
                     else {
@@ -977,8 +983,7 @@ export class UnionConvertor extends BaseArgConvertor {
         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)));
+        return writer.makeNaryOp("||", this.memberConvertors.map((_, n) => this.unionChecker.makeDiscriminator(value, n, writer)));
     }
 }
 export class FunctionConvertor extends BaseArgConvertor {
@@ -988,13 +993,13 @@ export class FunctionConvertor extends BaseArgConvertor {
         this.library = library;
     }
     convertorArg(param, writer) {
-        return writer.language == Language.CPP ? `makeArkFunctionFromId(${param})` : `registerCallback(${param})`;
+        throw new Error('Shall not be used');
     }
     convertorSerialize(param, value, writer) {
-        writer.writeMethodCall(`${param}Serializer`, "writeFunction", [value]);
+        throw new Error('Shall not be used');
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        return assigneer(writer.makeCast(writer.makeString(`${deserializerName}.readFunction()`), idl.IDLFunctionType, { optional: true }));
+        throw new Error('Shall not be used');
     }
     nativeType() {
         return idl.IDLFunctionType;
@@ -1017,16 +1022,21 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
             case Language.CPP:
                 return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
             case Language.JAVA:
+            case Language.KOTLIN:
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
+                if (isInExternalModule(this.declaration)) {
+                    const extractor = getExtractor(this.declaration, writer.language, true);
+                    return `${extractor.receiver}.${extractor.method}(${param})`;
+                }
                 return `toPeerPtr(${param})`;
         }
     }
     convertorSerialize(param, value, printer) {
         const accessorRoot = getSerializerName(this.declaration);
         printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        printer.writeStaticMethodCall(accessorRoot, 'write', [`${param}Serializer`, value]);
+        return printer.makeStatement(printer.makeStaticMethodCall(accessorRoot, 'write', [printer.makeString(`${param}Serializer`), printer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const accessorRoot = getSerializerName(this.declaration);
@@ -1046,62 +1056,11 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
     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 ExternalTypeConvertor extends BaseArgConvertor {
-    constructor(library, param, declaration) {
-        super(idl.createReferenceType(declaration), [RuntimeType.OBJECT], false, false, param);
-        this.library = library;
-        this.declaration = declaration;
-        console.log(`ExternalType convertor for type: ${declaration.name}`);
-    }
-    convertorArg(param, writer) {
-        const lang = writer.language;
-        switch (lang) {
-            case Language.CPP:
-                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
-            default:
-                return `extractors.${getExtractorName(this.declaration, lang, true)}(${param})`;
-        }
-    }
-    convertorSerialize(param, value, printer) {
-        const accessor = getSerializerName(this.declaration);
-        printer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        printer.writeStatement(printer.makeStatement(printer.makeStaticMethodCall(accessor, 'write', [
-            printer.makeString(`${param}Serializer`),
-            printer.makeString(value)
-        ])));
-    }
-    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessor = getSerializerName(this.declaration);
-        writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]), this.declaration);
-        return assigneer(readStatement);
-    }
-    nativeType() {
-        return idl.createReferenceType(this.declaration);
-    }
-    interopType() {
-        return idl.IDLPointerType;
-    }
-    isPointerType() {
-        return false;
-    }
-    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)]);
+                return writer.instanceOf(value, this.idlType);
             }
             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);
+                return this.discriminatorFromFields(value, writer, uniqueFields, it => it.name, it => it.isOptional);
             }
         }
     }
@@ -1116,7 +1075,7 @@ export class ImportTypeConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, printer) {
-        printer.writeMethodCall(`${param}Serializer`, "writeCustomObject", [`"${this.importedName}"`, value]);
+        return printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeCustomObject", [printer.makeString(`"${this.importedName}"`), printer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return assigneer(writer.makeString(`${deserializerName}.readCustomObject("${this.importedName}")`));
@@ -1151,14 +1110,15 @@ export class CallbackConvertor extends BaseArgConvertor {
     }
     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;
+            return writer.makeBlock([
+                writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writeCallbackResource", [writer.makeString(`${value}.resource`)])),
+                writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writePointer", [writer.makeCast(new StringExpression(`${value}.call`), idl.IDLPointerType, { unsafe: true })])),
+                writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writePointer", [writer.makeCast(new StringExpression(`${value}.callSync`), idl.IDLPointerType, { unsafe: true })]))
+            ], false);
         }
         if (this.isTransformed)
             value = `CallbackTransformer.transformFrom${this.library.getInteropName(this.decl)}(${value})`;
-        writer.writeMethodCall(`${param}Serializer`, `holdAndWriteCallback`, [`${value}`]);
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallback`, [writer.makeString(`${value}`)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer, useSyncVersion = false) {
         if (writer.language == Language.CPP) {
@@ -1175,12 +1135,12 @@ export class CallbackConvertor extends BaseArgConvertor {
             });
             return assigneer(writer.makeString(`{${resourceReadExpr.asString()}, ${callReadExpr.asString()}, ${callSyncReadExpr.asString()}}`));
         }
-        const resourceName = bufferName + "_resource";
-        const callName = bufferName + "_call";
-        const callSyncName = bufferName + '_callSync';
-        const argsSerializer = bufferName + "_args";
-        const continuationValueName = bufferName + "_continuationValue";
-        const continuationCallbackName = bufferName + "_continuationCallback";
+        const resourceName = bufferName + "BufResource";
+        const callName = bufferName + "BufCall";
+        const callSyncName = bufferName + 'BufCallSync';
+        const argsSerializer = bufferName + "BufArgs";
+        const continuationValueName = bufferName + "BufContinuationValue";
+        const continuationCallbackName = bufferName + "BufContinuationCallback";
         const statements = [];
         statements.push(writer.makeAssign(resourceName, idl.createReferenceType("CallbackResource"), writer.makeMethodCall(deserializerName, 'readCallbackResource', []), true));
         statements.push(writer.makeAssign(callName, idl.IDLPointerType, writer.makeMethodCall(deserializerName, `readPointer`, []), true));
@@ -1196,14 +1156,14 @@ export class CallbackConvertor extends BaseArgConvertor {
             continuation = [
                 writer.language == Language.CJ ?
                     writer.makeAssign(continuationValueName, undefined, writer.makeString(`${writer.getNodeName(this.decl.returnType).replace(/[\<\>]/g, '')}Holder(None<${writer.getNodeName(this.decl.returnType)}>)`), true, true) :
-                    writer.makeAssign(continuationValueName, optionalReturnType, undefined, true, false),
+                    writer.makeAssign(continuationValueName, optionalReturnType, writer.language == Language.KOTLIN ? writer.makeNull() : undefined, true, false),
                 writer.makeAssign(continuationCallbackName, continuationReference, writer.makeLambda(new NamedMethodSignature(idl.IDLVoidType, [returnType], [`value`]), [
                     writer.language == Language.CJ ?
                         writer.makeAssign(`${continuationValueName}.value`, undefined, writer.makeString(`value`), false) :
                         writer.makeAssign(continuationValueName, undefined, writer.makeString(`value`), false)
                 ]), true),
                 new ProxyStatement(writer => {
-                    continuationConvertor.convertorSerialize(argsSerializer, continuationCallbackName, writer);
+                    writer.writeStatement(continuationConvertor.convertorSerialize(argsSerializer, continuationCallbackName, writer));
                 }),
             ];
         }
@@ -1215,7 +1175,7 @@ export class CallbackConvertor extends BaseArgConvertor {
             ...this.decl.parameters.map(it => {
                 const convertor = this.library.typeConvertor(it.name, it.type, it.isOptional);
                 return new ProxyStatement((writer) => {
-                    convertor.convertorSerialize(argsSerializer, writer.escapeKeyword(it.name), writer);
+                    writer.writeStatement(convertor.convertorSerialize(argsSerializer, writer.escapeKeyword(it.name), writer));
                 });
             }),
             ...continuation,
@@ -1231,7 +1191,7 @@ export class CallbackConvertor extends BaseArgConvertor {
                     writer.makeString(`${argsSerializer}Serializer.length()`),
                 ])),
             new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `release`, [])),
-            writer.makeReturn(hasContinuation
+            writer.makeLambdaReturn(hasContinuation
                 ? writer.makeCast(writer.language == Language.CJ ?
                     writer.makeString(`${continuationValueName}.value`) :
                     writer.makeString(continuationValueName), this.decl.returnType)
@@ -1248,10 +1208,6 @@ export class CallbackConvertor extends BaseArgConvertor {
     isPointerType() {
         return true;
     }
-    unionDiscriminator(value, index, writer, duplicates) {
-        // We serialize callbacks as table offsets, so don't need to discriminate them. Runtime type check is enough
-        return writer.makeUnionVariantCondition(this, value, `${value}_type`, RuntimeType[RuntimeType.FUNCTION]);
-    }
 }
 ////////////////////////////////////////////////////////////////////////////////
 // UTILS
@@ -1314,13 +1270,18 @@ class PromiseOutArgConvertor extends BaseArgConvertor {
     }
     convertorSerialize(param, value, writer) {
         if (writer.language == Language.CPP) {
-            this.callbackConvertor.convertorSerialize(param, value, writer);
-            return;
+            return this.callbackConvertor.convertorSerialize(param, value, writer);
+        }
+        let serializeCallback;
+        if (idl.isVoidType(this.promise.elementType[0])) {
+            serializeCallback = writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallbackForPromiseVoid`, []);
+        }
+        else {
+            serializeCallback = writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallbackForPromise<${writer.getNodeName(this.promise.elementType[0])}>`, []);
         }
-        const serializeCallback = idl.isVoidType(this.promise.elementType[0])
-            ? writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallbackForPromiseVoid`, [])
-            : writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallbackForPromise<${writer.getNodeName(this.promise.elementType[0])}>`, []);
-        writer.writeStatement(writer.makeAssign(value, undefined, writer.language == Language.CJ ? writer.makeString(serializeCallback.asString().concat('.promise')) : writer.makeTupleAccess(serializeCallback.asString(), 0), true));
+        return writer.makeAssign(value, undefined, writer.language == Language.CJ
+            ? writer.makeString(serializeCallback.asString().concat('.promise'))
+            : writer.makeTupleAccess(serializeCallback.asString(), 0), true);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         return this.callbackConvertor.convertorDeserialize(bufferName, deserializerName, assigneer, writer);