@idlizer/core 2.1.9-arktscgen-8 → 2.1.10-arktscgen-2

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 { getExtractor, hashCodeFromString, throwException, 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";
@@ -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", []);
@@ -279,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 }));
@@ -304,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)}()`));
@@ -320,6 +322,31 @@ export class NumericConvertor extends BaseArgConvertor {
         return false;
     }
 }
+// TODO use NumericConvertor when double is implemented as interop type
+export class DoubleConvertor extends BaseArgConvertor {
+    constructor(param) {
+        // check numericPrimitiveTypes.include(type)
+        super(idl.IDLF64Type, [RuntimeType.NUMBER], false, true, param);
+    }
+    convertorArg(param, writer) {
+        return param;
+    }
+    convertorSerialize(param, value, writer) {
+        return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `writeFloat64`, [writer.makeString(value)]));
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeString(`${deserializerName}.readFloat64()`));
+    }
+    nativeType() {
+        return this.idlType;
+    }
+    interopType() {
+        return this.idlType;
+    }
+    isPointerType() {
+        return false;
+    }
+}
 export class BigIntToU64Convertor extends BaseArgConvertor {
     constructor(param) {
         super(idl.IDLBigintType, [RuntimeType.BIGINT], false, false, param);
@@ -327,8 +354,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 }));
@@ -359,13 +386,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 }));
@@ -394,8 +416,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()`));
@@ -417,8 +439,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 }));
@@ -455,12 +477,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 = [];
@@ -475,7 +501,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);
@@ -484,7 +511,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) {
@@ -502,7 +529,7 @@ export class AggregateConvertor extends BaseArgConvertor {
         }
         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));
         }
@@ -537,10 +564,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);
@@ -571,10 +601,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);
@@ -623,26 +653,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 = `${value}_counter_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)));
@@ -680,20 +711,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([
@@ -701,10 +734,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),
@@ -742,17 +775,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) {
@@ -787,7 +820,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();
@@ -822,7 +855,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
@@ -863,18 +896,12 @@ export class OptionConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, printer) {
-        printer.print(`if (${printer.makeDefinedCheck(value).asString()}) {`);
-        printer.pushIndent();
-        printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeRuntimeType(RuntimeType.OBJECT).asString()]);
-        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('} else {');
-        printer.pushIndent();
-        printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeRuntimeType(RuntimeType.UNDEFINED).asString()]);
-        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");
@@ -891,7 +918,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)));
@@ -924,23 +951,23 @@ export class UnionConvertor extends BaseArgConvertor {
         throw new Error("Do not use for union");
     }
     convertorSerialize(param, value, printer) {
-        this.memberConvertors.forEach((it, index) => {
-            const maybeElse = (index > 0 && this.memberConvertors[index - 1].runtimeTypes.length > 0) ? "else " : "";
-            const discriminator = this.unionChecker.makeDiscriminator(value, index, printer).asString();
-            printer.print(`${maybeElse}if (${discriminator}) {`);
-            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 };
         });
+        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);
@@ -953,7 +980,7 @@ 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) => {
+                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);
                     }
@@ -991,13 +1018,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;
@@ -1034,7 +1061,7 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
     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);
@@ -1073,7 +1100,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}")`));
@@ -1108,16 +1135,17 @@ 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) {
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer, useSyncVersion = true) {
         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)})`);
@@ -1132,12 +1160,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));
@@ -1160,7 +1188,7 @@ export class CallbackConvertor extends BaseArgConvertor {
                         writer.makeAssign(continuationValueName, undefined, writer.makeString(`value`), false)
                 ]), true),
                 new ProxyStatement(writer => {
-                    continuationConvertor.convertorSerialize(argsSerializer, continuationCallbackName, writer);
+                    writer.writeStatement(continuationConvertor.convertorSerialize(argsSerializer, continuationCallbackName, writer));
                 }),
             ];
         }
@@ -1172,17 +1200,19 @@ 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,
             new ExpressionStatement(useSyncVersion
                 ? writer.makeNativeCall(this.interopModuleName, `_CallCallbackSync`, [
+                    writer.makeString(generatorConfiguration().ApiKind.toString()),
                     writer.makeString(generateCallbackKindValue(this.decl).toString()),
                     writer.makeSerializedBufferGetter(`${argsSerializer}Serializer`),
                     writer.makeString(`${argsSerializer}Serializer.length()`),
                 ])
                 : writer.makeNativeCall(this.interopModuleName, `_CallCallback`, [
+                    writer.makeString(generatorConfiguration().ApiKind.toString()),
                     writer.makeString(generateCallbackKindValue(this.decl).toString()),
                     writer.makeSerializedBufferGetter(`${argsSerializer}Serializer`),
                     writer.makeString(`${argsSerializer}Serializer.length()`),
@@ -1267,13 +1297,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);

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -84,8 +84,9 @@ export declare class ExpressionStatement implements LanguageStatement {
 }
 export declare class BlockStatement implements LanguageStatement {
     statements: LanguageStatement[];
-    private inScope;
-    constructor(statements: LanguageStatement[], inScope?: boolean);
+    readonly inScope: boolean;
+    private newLine;
+    constructor(statements: LanguageStatement[], inScope?: boolean, newLine?: boolean);
     write(writer: LanguageWriter): void;
 }
 export declare class IfStatement implements LanguageStatement {
@@ -131,7 +132,7 @@ export declare abstract class LambdaExpression implements LanguageExpression {
     constructor(originalWriter: LanguageWriter, signature: MethodSignature, resolver: ReferenceResolver, body?: LanguageStatement[] | undefined);
     protected abstract get statementHasSemicolon(): boolean;
     abstract asString(): string;
-    bodyAsString(): string;
+    bodyAsString(isScoped?: boolean): string;
 }
 export declare enum ArgumentModifier {
     OPTIONAL = 0
@@ -283,7 +284,7 @@ export declare abstract class LanguageWriter {
     abstract makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
     abstract makeLoop(counter: string, limit: string): LanguageStatement;
     abstract makeLoop(counter: string, limit: string, statement: LanguageStatement): LanguageStatement;
-    abstract makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    abstract makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     abstract getTagType(): idl.IDLType;
     abstract getRuntimeType(): idl.IDLType;
     abstract makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;