@idlizer/core 2.1.9-arktscgen-5 → 2.1.9-arktscgen-8

package/build/lib/src/Language.d.ts

@@ -1,7 +1,6 @@
 export declare class Language {
     name: string;
     extension: string;
-    needsUnionDiscrimination: boolean;
     static TS: Language;
     static ARKTS: Language;
     static JAVA: Language;

package/build/lib/src/Language.js

@@ -13,10 +13,9 @@
  * limitations under the License.
  */
 export class Language {
-    constructor(name, extension, needsUnionDiscrimination) {
+    constructor(name, extension) {
         this.name = name;
         this.extension = extension;
-        this.needsUnionDiscrimination = needsUnionDiscrimination;
     }
     toString() {
         return this.name;
@@ -36,10 +35,10 @@ export class Language {
         }
     }
 }
-Language.TS = new Language("TS", ".ts", true);
-Language.ARKTS = new Language("ArkTS", ".ts", true); // using .ts for ArkTS until we get rit of tsc preprocessing
-Language.JAVA = new Language("Java", ".java", false);
-Language.CPP = new Language("C++", ".cc", false);
-Language.CJ = new Language("CangJie", ".cj", false);
-Language.KOTLIN = new Language("Kotlin", ".kt", false);
+Language.TS = new Language("TS", ".ts");
+Language.ARKTS = new Language("ArkTS", ".ts"); // using .ts for ArkTS until we get rit of tsc preprocessing
+Language.JAVA = new Language("Java", ".java");
+Language.CPP = new Language("C++", ".cc");
+Language.CJ = new Language("CangJie", ".cj");
+Language.KOTLIN = new Language("Kotlin", ".kt");
 //# sourceMappingURL=Language.js.map

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

@@ -5,6 +5,7 @@ import { NativeModuleType, RuntimeType } from "./common";
 import { LibraryInterface } from "../LibraryInterface";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PeerLibrary } from "../peer-generation/PeerLibrary";
+import { PeerMethodSignature } from "../peer-generation/PeerMethod";
 export declare function getSerializerName(declaration: idl.IDLEntry): string;
 export interface ArgConvertor {
     param: string;
@@ -26,7 +27,7 @@ export interface ArgConvertor {
     getObjectAccessor(languge: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
 }
 export declare function isDirectConvertedType(originalType: idl.IDLType | undefined, library: PeerLibrary): boolean;
-export declare function isVMContextMethod(method: Method): boolean;
+export declare function isVMContextMethod(method: Method | PeerMethodSignature): boolean;
 export declare function isDirectMethod(method: Method, library: PeerLibrary): boolean;
 export declare abstract class BaseArgConvertor implements ArgConvertor {
     idlType: idl.IDLType;
@@ -46,7 +47,7 @@ export declare abstract class BaseArgConvertor implements ArgConvertor {
     unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
     getMembers(): string[];
     getObjectAccessor(language: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
-    protected discriminatorFromFields<T>(value: string, writer: LanguageWriter, uniqueFields: T[] | undefined, nameAccessor: (field: T) => string, optionalAccessor: (field: T) => boolean, duplicates: Set<string>): LanguageExpression | undefined;
+    protected discriminatorFromFields<T>(value: string, writer: LanguageWriter, uniqueFields: T[] | undefined, nameAccessor: (field: T) => string, optionalAccessor: (field: T) => boolean): LanguageExpression | undefined;
 }
 export declare class BooleanConvertor extends BaseArgConvertor {
     constructor(param: string);
@@ -313,18 +314,6 @@ export declare class MaterializedClassConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
     unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
 }
-export declare class ExternalTypeConvertor extends BaseArgConvertor {
-    private library;
-    declaration: idl.IDLInterface;
-    constructor(library: PeerLibrary, param: string, declaration: idl.IDLInterface);
-    convertorArg(param: string, writer: LanguageWriter): string;
-    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
-    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
-    nativeType(): idl.IDLType;
-    interopType(): idl.IDLType;
-    isPointerType(): boolean;
-    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
-}
 export declare class ImportTypeConvertor extends BaseArgConvertor {
     protected importedName: string;
     constructor(param: string, importedName: string);
@@ -347,7 +336,6 @@ export declare class CallbackConvertor extends BaseArgConvertor {
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter, useSyncVersion?: boolean): LanguageStatement;
     nativeType(): idl.IDLType;
     isPointerType(): boolean;
-    unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
 }
 export declare const CallbackKind = "CallbackKind";
 export declare function generateCallbackKindName(callback: idl.IDLCallback): string;
@@ -355,4 +343,5 @@ export declare function generateCallbackKindAccess(callback: idl.IDLCallback, la
 export declare function generateCallbackKindValue(callback: idl.IDLCallback): number;
 export declare function generateCallbackAPIArguments(library: LibraryInterface, callback: idl.IDLCallback): string[];
 export declare function maybeTransformManagedCallback(callback: idl.IDLCallback, library: ReferenceResolver): idl.IDLCallback | undefined;
+export declare function createOutArgConvertor(library: PeerLibrary, type: idl.IDLType | undefined, otherParams: string[]): ArgConvertor | undefined;
 //# sourceMappingURL=ArgConvertors.d.ts.map

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

@@ -17,13 +17,15 @@ 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 { getExtractor, hashCodeFromString, throwException, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 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`;
 }
@@ -76,7 +78,8 @@ export function isDirectConvertedType(originalType, library) {
 }
 export function isVMContextMethod(method) {
     var _a, _b;
-    return !!idl.asPromise(method.signature.returnType) ||
+    const isPromise = !!idl.asPromise(method instanceof PeerMethodSignature ? method.returnType : method.signature.returnType);
+    return isPromise ||
         !!((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS)) ||
         !!((_b = method.modifiers) === null || _b === void 0 ? void 0 : _b.includes(MethodModifier.FORCE_CONTEXT)) ||
         generatorConfiguration().forceContext.includes(method.name);
@@ -120,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 {
@@ -249,7 +251,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 {
@@ -417,7 +433,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 {
@@ -478,6 +494,12 @@ 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}`)];
@@ -504,7 +526,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 {
@@ -578,7 +600,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 {
@@ -586,7 +608,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,7 +625,7 @@ export class ArrayConvertor extends BaseArgConvertor {
     convertorSerialize(param, value, printer) {
         // Array length.
         const valueLength = printer.makeArrayLength(value).asString();
-        const loopCounter = "i";
+        const loopCounter = `${value}_counter_i`;
         printer.writeMethodCall(`${param}Serializer`, "writeInt32", [printer.castToInt(valueLength, 32)]);
         printer.writeStatement(printer.makeLoop(loopCounter, valueLength));
         printer.pushIndent();
@@ -636,7 +658,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" : "";
@@ -700,7 +722,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)
@@ -710,7 +732,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) {
@@ -841,30 +863,18 @@ 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.print(`if (${printer.makeDefinedCheck(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>
-        }
+        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(`}`);
-        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('}');
-        }
+        printer.print('} else {');
+        printer.pushIndent();
+        printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeRuntimeType(RuntimeType.UNDEFINED).asString()]);
+        printer.popIndent();
+        printer.print('}');
     }
     convertorCArg(param) {
         throw new Error("Must never be used");
@@ -914,13 +924,10 @@ 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()}) {`);
+            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)]);
             if (!(it instanceof UndefinedConvertor)) {
@@ -930,7 +937,6 @@ export class UnionConvertor extends BaseArgConvertor {
             printer.popIndent();
             printer.print(`}`);
         });
-        this.unionChecker.reportConflicts((_a = this.library.getCurrentContext()) !== null && _a !== void 0 ? _a : "<unknown context>", printer);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const statements = [];
@@ -948,7 +954,7 @@ export class UnionConvertor extends BaseArgConvertor {
             const stmt = new BlockStatement([
                 writer.makeSetUnionSelector(bufferName, `${index}`),
                 it.convertorDeserialize(`${bufferName}_u`, deserializerName, (expr) => {
-                    if (writer.language == Language.CJ) {
+                    if (writer.language == Language.CJ || writer.language == Language.KOTLIN) {
                         return writer.makeAssign(receiver, undefined, writer.makeFunctionCall(writer.getNodeName(this.type), [expr]), false);
                     }
                     else {
@@ -975,8 +981,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 {
@@ -1015,9 +1020,14 @@ 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})`;
         }
     }
@@ -1044,62 +1054,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)]);
+                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);
-            }
-        }
-    }
-}
-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)]);
-            }
-            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);
             }
         }
     }
@@ -1194,7 +1153,7 @@ 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) :
@@ -1229,7 +1188,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)
@@ -1246,10 +1205,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
@@ -1294,4 +1249,50 @@ export function maybeTransformManagedCallback(callback, library) {
         return library.resolveTypeReference(idl.createReferenceType("CustomNodeBuilder"));
     return undefined;
 }
+class PromiseOutArgConvertor extends BaseArgConvertor {
+    constructor(library, param, promise) {
+        super(library.createContinuationCallbackReference(promise), [RuntimeType.FUNCTION], false, true, param);
+        this.library = library;
+        this.promise = promise;
+        this.isOut = true;
+        const type = this.idlType;
+        const callbackEntry = library.resolveTypeReference(type);
+        if (!callbackEntry)
+            throw new Error(`Internal error: no callback for ${type.name} resolved`);
+        this.callback = callbackEntry;
+        this.callbackConvertor = new CallbackConvertor(library, param, this.callback, this.library.interopNativeModule);
+    }
+    convertorArg(param, writer) {
+        return this.callbackConvertor.convertorArg(param, writer);
+    }
+    convertorSerialize(param, value, writer) {
+        if (writer.language == Language.CPP) {
+            this.callbackConvertor.convertorSerialize(param, value, writer);
+            return;
+        }
+        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));
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return this.callbackConvertor.convertorDeserialize(bufferName, deserializerName, assigneer, writer);
+    }
+    nativeType() {
+        return this.idlType;
+    }
+    isPointerType() {
+        return true;
+    }
+}
+export function createOutArgConvertor(library, type, otherParams) {
+    if (type && idl.isContainerType(type) && idl.IDLContainerUtils.isPromise(type)) {
+        const param = (entropy) => `outputArgumentForReturningPromise${entropy || ''}`;
+        let paramEntropy = 0;
+        while (otherParams === null || otherParams === void 0 ? void 0 : otherParams.includes(param(paramEntropy)))
+            ++paramEntropy;
+        return new PromiseOutArgConvertor(library, param(paramEntropy), type);
+    }
+    return undefined;
+}
 //# sourceMappingURL=ArgConvertors.js.map

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

@@ -59,11 +59,6 @@ export declare class FieldAccessExpression {
     constructor(receiver: string, field: string, nullable?: boolean);
     asString(): string;
 }
-export declare class CheckDefinedExpression implements LanguageExpression {
-    private value;
-    constructor(value: string);
-    asString(): string;
-}
 export interface LanguageStatement {
     write(writer: LanguageWriter): void;
 }
@@ -113,13 +108,6 @@ export declare class MultiBranchIfStatement implements LanguageStatement {
     constructor(statements: BranchStatement[], elseStatement: LanguageStatement | undefined);
     write(writer: LanguageWriter): void;
 }
-export declare class CheckOptionalStatement implements LanguageStatement {
-    undefinedValue: string;
-    optionalExpression: LanguageExpression;
-    doStatement: LanguageStatement;
-    constructor(undefinedValue: string, optionalExpression: LanguageExpression, doStatement: LanguageStatement);
-    write(writer: LanguageWriter): void;
-}
 export declare class TsEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
     private readonly options;
@@ -156,7 +144,8 @@ export declare enum FieldModifier {
     PROTECTED = 4,
     FINAL = 5,
     VOLATILE = 6,
-    INTERNAL = 7
+    INTERNAL = 7,
+    OVERRIDE = 8
 }
 export declare enum MethodModifier {
     PUBLIC = 0,
@@ -274,14 +263,13 @@ export declare abstract class LanguageWriter {
     }, setter?: {
         method: Method;
         op: () => void;
-    }): void;
+    }, initExpr?: LanguageExpression): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     abstract makeThrowError(message: string): LanguageStatement;
     abstract makeReturn(expr?: LanguageExpression): LanguageStatement;
-    abstract makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     abstract makeRuntimeType(rt: RuntimeType): LanguageExpression;
     abstract getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     abstract makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
@@ -324,6 +312,7 @@ export declare abstract class LanguageWriter {
     makeThis(): LanguageExpression;
     makeNull(value?: string): LanguageExpression;
     makeVoid(): LanguageExpression;
+    makeLambdaReturn(expr?: LanguageExpression): LanguageStatement;
     makeRuntimeTypeCondition(typeVarName: string, equals: boolean, type: RuntimeType, varName?: string): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
@@ -335,7 +324,7 @@ export declare abstract class LanguageWriter {
     makeNativeCall(nativeModule: NativeModuleType, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeBlock(statements: LanguageStatement[], inScope?: boolean): BlockStatement;
     nativeReceiver(nativeModule: NativeModuleType): string;
-    makeDefinedCheck(value: string): LanguageExpression;
+    abstract makeDefinedCheck(value: string, isTag?: boolean): LanguageExpression;
     makeRuntimeTypeDefinedCheck(runtimeType: string): LanguageExpression;
     makeCondition(condition: LanguageExpression, thenStatement: LanguageStatement, elseStatement?: LanguageStatement, insideIfOp?: () => void, insideElseOp?: () => void): LanguageStatement;
     makeMultiBranchCondition(conditions: BranchStatement[], elseStatement?: LanguageStatement): LanguageStatement;
@@ -344,7 +333,6 @@ export declare abstract class LanguageWriter {
     makeArrayAccess(value: string, indexVar: string): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
     makeUnionSelector(value: string, valueType: string): LanguageStatement;
-    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, _convertorIndex?: number, _runtimeTypeIndex?: number): LanguageExpression;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
     makeUnionTypeDefaultInitializer(): LanguageExpression;
     makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
@@ -357,15 +345,11 @@ export declare abstract class LanguageWriter {
     makeNaryOp(op: string, args: LanguageExpression[]): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     writeNativeMethodDeclaration(method: Method): void;
-    writeUnsafeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     pushIndent(): void;
     popIndent(): void;
     print(string: stringOrNone): void;
     getOutput(): string[];
     makeSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): MethodSignature;
-    makeNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
-    makeNativeMethodNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
-    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
     mapFieldModifier(modifier: FieldModifier): string;
     mapMethodModifier(modifier: MethodModifier): string;
     /**
@@ -374,10 +358,6 @@ export declare abstract class LanguageWriter {
     makeUnsafeCast(param: string): string;
     makeUnsafeCast_(value: LanguageExpression, type: idl.IDLType, typeOptions?: PrintHint): string;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    makeDiscriminatorFromFields(convertor: {
-        targetType: (writer: LanguageWriter) => string;
-    }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
-    makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
     makeEnumEntity(enumEntity: idl.IDLEnum, options: {
         isExport: boolean;
         isDeclare?: boolean;
@@ -385,9 +365,8 @@ export declare abstract class LanguageWriter {
     makeFieldModifiersList(modifiers: FieldModifier[] | undefined, customFieldFilter?: (field: FieldModifier) => boolean): string;
     escapeKeyword(keyword: string): string;
     makeCastCustomObject(customName: string, _isGenericType: boolean): LanguageExpression;
-    makeHasOwnProperty(value: string, _valueTypeName: string, property: string, propertyTypeName?: string): LanguageExpression;
-    discriminatorFromExpressions(value: string, runtimeType: RuntimeType, exprs: LanguageExpression[]): LanguageExpression;
-    makeDiscriminatorConvertor(_convertor: ArgConvertor, _value: string, _index: number): LanguageExpression | undefined;
+    makeHasOwnProperty(value: string, property: string, propertyTypeName?: string): LanguageExpression;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     makeNot(expr: LanguageExpression): LanguageExpression;
     makeSerializedBufferGetter(serializer: string): LanguageExpression;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
@@ -395,9 +374,8 @@ export declare abstract class LanguageWriter {
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
     makeStaticBlock(op: (writer: LanguageWriter) => void): void;
-    instanceOf(convertor: ArgConvertor, value: string, _duplicateMembers?: Set<string>): LanguageExpression;
+    instanceOf(value: string, type: idl.IDLType): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
-    stringifyTypeOrEmpty(type: idl.IDLType | undefined): string;
     /**
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin