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

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.d.ts

@@ -1,10 +1,11 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature } from "../LanguageWriter";
 import { TSLanguageWriter } from "./TsLanguageWriter";
 import { IDLEnum, IDLType } from '../../idl';
 import { ArgConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
 import { IdlNameConvertor } from "../nameConvertor";
+import { RuntimeType } from "../common";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
 export declare class EtsAssignStatement implements LanguageStatement {
     variableName: string;
@@ -12,7 +13,8 @@ export declare class EtsAssignStatement implements LanguageStatement {
     expression: LanguageExpression;
     isDeclared: boolean;
     protected isConst: boolean;
-    constructor(variableName: string, type: IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean);
+    protected options?: MakeAssignOptions | undefined;
+    constructor(variableName: string, type: IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions | undefined);
     write(writer: LanguageWriter): void;
 }
 export declare class ArkTSEnumEntityStatement implements LanguageStatement {
@@ -40,7 +42,7 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
-    makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
+    makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
@@ -53,23 +55,18 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
-    makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
     makeEnumEntity(enumEntity: IDLEnum, options: {
         isExport: boolean;
         isDeclare?: boolean;
     }): LanguageStatement;
-    getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     isQuickType(type: IDLType): boolean;
     writeNativeMethodDeclaration(method: Method): void;
-    makeUnionVariantCondition(convertor: ArgConvertor, valueName: string, valueType: string, type: string, convertorIndex: number, runtimeTypeIndex: number): LanguageExpression;
     makeCastCustomObject(customName: string, isGenericType: boolean): LanguageExpression;
-    makeHasOwnProperty(value: string, valueTypeName: string, property: string, propertyTypeName: string): LanguageExpression;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
-    makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
-    instanceOf(convertor: ArgConvertor, value: string, duplicateMembers?: Set<string>): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.js

@@ -16,24 +16,25 @@ import { IndentedPrinter } from "../../IndentedPrinter";
 import { LambdaExpression, MethodModifier } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
 import { getExtAttribute, IDLThisType } from '../../idl';
-import { AggregateConvertor, ArrayConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor, OptionConvertor, UnionConvertor, BufferConvertor } from "../ArgConvertors";
+import { AggregateConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
 import { convertDeclaration } from "../nameConvertor";
 import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
 import { Language } from "../../Language";
-import { RuntimeType } from "../common";
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
 export class EtsAssignStatement {
-    constructor(variableName, type, expression, isDeclared = true, isConst = true) {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true, options) {
         this.variableName = variableName;
         this.type = type;
         this.expression = expression;
         this.isDeclared = isDeclared;
         this.isConst = isConst;
+        this.options = options;
     }
     write(writer) {
+        var _a;
         if (this.isDeclared) {
             const typeClause = this.type !== undefined ? `: ${writer.getNodeName(this.type)}` : '';
             const maybeAssign = this.expression !== undefined ? " = " : "";
@@ -41,7 +42,9 @@ export class EtsAssignStatement {
             writer.print(`${this.isConst ? "const" : "let"} ${this.variableName} ${typeClause}${maybeAssign}${initValue.asString()}`);
         }
         else {
-            writer.print(`${this.variableName} = ${this.expression.asString()}`);
+            const receiver = (_a = this.options) === null || _a === void 0 ? void 0 : _a.receiver;
+            const withReceiver = receiver ? `${receiver}.` : "";
+            writer.print(`${withReceiver}${this.variableName} = ${this.expression.asString()}`);
         }
     }
 }
@@ -130,10 +133,10 @@ export class ETSLambdaExpression extends LambdaExpression {
 //                           UTILS                            //
 ////////////////////////////////////////////////////////////////
 export function generateTypeCheckerName(typeName) {
-    typeName = typeName
+    return "is" + typeName
         .replaceAll('[]', 'BracketsArray')
-        .split('.').join('_');
-    return `is${typeName.replaceAll('[]', 'Brackets')}`;
+        .replaceAll(/<.*$/g, '') // delete type arguments
+        .replaceAll('.', '_');
 }
 export function generateEnumToNumericName(entry) {
     const typeName = idl.getQualifiedName(entry, "namespace.name").split('.').join('_');
@@ -159,8 +162,8 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         var _a;
         return new ETSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
     }
-    makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
-        return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst);
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
+        return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst, options);
     }
     makeLambda(signature, body) {
         return new ETSLambdaExpression(this, this.typeConvertor, signature, this.resolver, body);
@@ -202,7 +205,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
             || convertor instanceof InterfaceConvertor
             || convertor instanceof MaterializedClassConvertor
             || convertor instanceof CustomTypeConvertor) {
-            return this.instanceOf(convertor, value, duplicates);
+            return this.instanceOf(value, convertor.idlType);
         }
         return this.makeString(`${value} instanceof ${convertor.targetType(this)}`);
     }
@@ -212,18 +215,12 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         return super.makeValueFromOption(value, destinationConvertor);
     }
-    makeIsTypeCall(value, decl) {
-        return makeInterfaceTypeCheckerCall(value, decl.name, decl.properties.map(it => it.name), new Set(), this);
-    }
     makeEnumEntity(enumEntity, options) {
         return new ArkTSEnumEntityStatement(enumEntity, {
             isExport: options === null || options === void 0 ? void 0 : options.isExport,
             isDeclare: !!(options === null || options === void 0 ? void 0 : options.isDeclare),
         });
     }
-    getObjectAccessor(convertor, value, args) {
-        return super.getObjectAccessor(convertor, value, args);
-    }
     writeMethodCall(receiver, method, params, nullable = false) {
         // ArkTS does not support - 'this.?'
         super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
@@ -237,46 +234,27 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
     }
-    makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
-        if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
-            return this.instanceOf(convertor, valueName);
-        }
-        // TODO: in ArkTS SerializerBase.runtimeType returns RuntimeType.OBJECT for enum type and not RuntimeType.NUMBER as in TS
-        if (convertor instanceof UnionConvertor || convertor instanceof OptionConvertor) {
-            // Unwrapping of type
-            const idlType = convertor instanceof UnionConvertor
-                ? convertor.nativeType().types[runtimeTypeIndex]
-                : idl.maybeUnwrapOptionalType(convertor.nativeType());
-            if (idlType !== undefined && idl.isReferenceType(idlType)) {
-                const resolved = this.resolver.resolveTypeReference(idlType);
-                type = resolved != undefined && idl.isEnum(resolved) ? RuntimeType[RuntimeType.OBJECT] : type;
-            }
-        }
-        return super.makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex);
-    }
     makeCastCustomObject(customName, isGenericType) {
         if (isGenericType) {
             return this.makeCast(this.makeString(customName), idl.IDLObjectType);
         }
         return super.makeCastCustomObject(customName, isGenericType);
     }
-    makeHasOwnProperty(value, valueTypeName, property, propertyTypeName) {
-        return this.makeNaryOp("&&", [
-            this.makeString(`${value} instanceof ${valueTypeName}`),
-            this.makeString(`isInstanceOf("${propertyTypeName}", ${value}.${property})`)
-        ]);
-    }
     makeEquals(args) {
         // TODO: Error elimination: 'TypeError: Both operands have to be reference types'
         // the '==' operator must be used when one of the operands is a reference
         return super.makeNaryOp('==', args);
     }
-    makeDiscriminatorConvertor(convertor, value, index) {
-        return this.instanceOf(convertor, value);
-        // Or this ????????
-        // return this.discriminatorFromExpressions(value, RuntimeType.OBJECT, [
-        //     makeEnumTypeCheckerCall(value, this.getNodeName(convertor.idlType), this)
-        // ])
+    discriminate(value, index, type, runtimeTypes) {
+        // work around ArkTS compiler bugs
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            const arrayTypeName = this.arrayConvertor.convert(type);
+            return `TypeChecker.${generateTypeCheckerName(arrayTypeName)}(${value})`;
+        }
+        if (this.getNodeName(type) === "DragPreviewMode") {
+            return `TypeChecker.isDragPreviewMode(${value})`;
+        }
+        return `${value} instanceof ${this.getNodeName(type)}`;
     }
     castToInt(value, bitness) {
         // This fix is used to avoid unnecessary writeInt8(value as int32) call, which is generated if value is already an int32
@@ -287,27 +265,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? 1 : 0`; }
-    instanceOf(convertor, value, duplicateMembers) {
-        if (convertor instanceof CustomTypeConvertor) {
-            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), [], duplicateMembers, this);
-        }
-        if (convertor instanceof InterfaceConvertor || convertor instanceof MaterializedClassConvertor) {
-            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), convertor.declaration.properties.filter(it => !it.isStatic).map(it => it.name), duplicateMembers, this);
-        }
-        if (convertor instanceof BufferConvertor) {
-            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), [], new Set(), this);
-        }
-        if (convertor instanceof AggregateConvertor) {
-            return makeInterfaceTypeCheckerCall(value, convertor.aliasName !== undefined ? convertor.aliasName : this.getNodeName(convertor.idlType), convertor.members.map(it => it[0]), duplicateMembers, this);
-        }
-        if (convertor instanceof ArrayConvertor) {
-            return makeArrayTypeCheckCall(value, this.arrayConvertor.convert(convertor.idlType), this);
-        }
-        if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
-            return makeEnumTypeCheckerCall(value, this.getNodeName(convertor.idlType), this);
-        }
-        return super.instanceOf(convertor, value, duplicateMembers);
-    }
     typeInstanceOf(type, value, members) {
         if (!members || members.length === 0) {
             throw new Error("At least one member needs to provided to pass it to TypeChecker!");

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts

@@ -6,11 +6,6 @@ import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
-export declare class JavaCheckDefinedExpression implements LanguageExpression {
-    private value;
-    constructor(value: string);
-    asString(): string;
-}
 export declare class JavaCastExpression implements LanguageExpression {
     value: LanguageExpression;
     type: string;
@@ -46,13 +41,12 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     }, setter?: {
         method: Method;
         op: () => void;
-    }): void;
+    }, initExpr?: LanguageExpression): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     makeDefinedCheck(value: string): LanguageExpression;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.js

@@ -14,7 +14,7 @@
  */
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, CheckOptionalStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
+import { AssignStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
 import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import * as idl from '../../idl';
 import { RuntimeType } from "../common";
@@ -33,14 +33,6 @@ class JavaLambdaExpression extends LambdaExpression {
         return `(${params.join(", ")}) -> { ${this.bodyAsString()} }`;
     }
 }
-export class JavaCheckDefinedExpression {
-    constructor(value) {
-        this.value = value;
-    }
-    asString() {
-        return `${this.value} != null`;
-    }
-}
 export class JavaCastExpression {
     constructor(value, type, unsafe = false) {
         this.value = value;
@@ -156,7 +148,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, modifiers, getter, setter) {
+    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let isStatic = modifiers.includes(FieldModifier.STATIC);
         let isMutable = !modifiers.includes(FieldModifier.READONLY);
         let containerName = propName.concat("_container");
@@ -177,6 +169,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
             }
         }
         else {
+            // TBD: use initExpr
             this.writeMethodDeclaration(propName, new MethodSignature(propType, []));
         }
     }
@@ -195,11 +188,8 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeReturn(expr) {
         return new CLikeReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        return new CheckOptionalStatement("null", optional, doStatement);
-    }
     makeDefinedCheck(value) {
-        return new JavaCheckDefinedExpression(value);
+        return this.makeString(`${value} != null`);
     }
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);

package/build/lib/src/LanguageWriters/writers/KotlinLanguageWriter.d.ts

@@ -6,6 +6,11 @@ import { ArgConvertor } from "../ArgConvertors";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class KotlinLambdaReturnStatement implements LanguageStatement {
+    expression?: LanguageExpression | undefined;
+    constructor(expression?: LanguageExpression | undefined);
+    write(writer: LanguageWriter): void;
+}
 export declare class KotlinEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
     private readonly options;
@@ -49,11 +54,6 @@ export declare class KotlinNewObjectExpression implements LanguageExpression {
     constructor(objectName: string, params: LanguageExpression[]);
     asString(): string;
 }
-export declare class KotlinCheckDefinedExpression implements LanguageExpression {
-    private value;
-    constructor(value: string);
-    asString(): string;
-}
 export declare class KotlinLanguageWriter extends LanguageWriter {
     protected typeConvertor: IdlNameConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, language?: Language);
@@ -78,6 +78,8 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     private writeDeclaration;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeNativeMethodDeclaration(method: Method): void;
+    private convertInteropArgument;
+    private convertInteropReturnValue;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
@@ -87,7 +89,7 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     }, setter?: {
         method: Method;
         op: () => void;
-    }): void;
+    }, initExpr?: LanguageExpression): void;
     writeGetterImplementation(method: Method, op?: (writer: this) => void): void;
     writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
@@ -97,7 +99,7 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeThrowError(message: string): LanguageStatement;
     makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
+    makeLambdaReturn(expr: LanguageExpression): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
@@ -108,8 +110,10 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeUndefined(): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
     makeTupleAlloc(option: string): LanguageStatement;
+    makeTupleAccess(value: string, index: number): LanguageExpression;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
     makeArrayLength(array: string, length?: string): LanguageExpression;
+    makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
     makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     makeMapInit(type: idl.IDLType): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
@@ -136,7 +140,6 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     escapeKeyword(keyword: string): string;
-    makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression | undefined;
     makeStaticBlock(op: (writer: LanguageWriter) => void): void;
     pushNamespace(namespace: string, options: {
         ident: boolean;

package/build/lib/src/LanguageWriters/writers/KotlinLanguageWriter.js

@@ -15,11 +15,19 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature } from "../LanguageWriter";
+import { AssignStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, ReturnStatement } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { isDefined } from "../../util";
-import { TSReturnStatement } from './TsLanguageWriter';
 import { removePoints } from '../convertors/CJConvertors';
+export class KotlinLambdaReturnStatement {
+    constructor(expression) {
+        this.expression = expression;
+    }
+    write(writer) {
+        if (this.expression)
+            writer.print(`${this.expression.asString()}`);
+    }
+}
 export class KotlinEnumEntityStatement {
     constructor(enumEntity, options) {
         this.enumEntity = enumEntity;
@@ -122,6 +130,17 @@ export class KotlinThrowErrorStatement {
         writer.print(`throw Error("${this.message}")`);
     }
 }
+class KotlinArrayResizeStatement {
+    constructor(array, arrayType, length, deserializer) {
+        this.array = array;
+        this.arrayType = arrayType;
+        this.length = length;
+        this.deserializer = deserializer;
+    }
+    write(writer) {
+        writer.print(`${this.array} = ${this.arrayType}(${this.length})`);
+    }
+}
 export class KotlinLoopStatement {
     constructor(counter, limit, statement) {
         this.counter = counter;
@@ -171,14 +190,6 @@ export class KotlinNewObjectExpression {
         return `${this.objectName}(${this.params.map(it => it.asString()).join(", ")})`;
     }
 }
-export class KotlinCheckDefinedExpression {
-    constructor(value) {
-        this.value = value;
-    }
-    asString() {
-        return `${this.value} != null`;
-    }
-}
 class KotlinUnwrapOptionalExpression {
     constructor(value) {
         this.value = value;
@@ -210,6 +221,13 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return new KotlinLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
+        // another stub. Bad one.
+        // I hope that I will rewrite LWs soon
+        if (idl.isType(type) && idl.isReferenceType(type)) {
+            if (type.name.startsWith('%TEXT%:')) {
+                return type.name.substring(7);
+            }
+        }
         return this.typeConvertor.convert(type);
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
@@ -226,7 +244,8 @@ export class KotlinLanguageWriter extends LanguageWriter {
         this.printer.print(`}`);
     }
     writeInterface(name, op, superInterfaces, generics, isDeclared) {
-        this.printer.print(`public interface ${name} {`);
+        const inheritance = superInterfaces ? (superInterfaces.length > 0 ? `: ${superInterfaces.join(', ')}` : '') : '';
+        this.printer.print(`public interface ${name}${inheritance} {`);
         this.pushIndent();
         op(this);
         this.popIndent();
@@ -273,7 +292,73 @@ export class KotlinLanguageWriter extends LanguageWriter {
     writeNativeMethodDeclaration(method) {
         let name = method.name;
         let signature = method.signature;
-        this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => { });
+        this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => {
+            const args = signature.args.map((type, index) => this.convertInteropArgument(signature.argName(index), type));
+            const interopCallExpression = this.makeFunctionCall(`kotlin${name}`, args);
+            if (signature.returnType === idl.IDLVoidType) {
+                this.writeExpressionStatement(interopCallExpression);
+                return;
+            }
+            const retval = "retval";
+            this.writeStatement(this.makeAssign(retval, undefined, interopCallExpression));
+            this.writeStatement(this.makeReturn(this.convertInteropReturnValue(retval, signature.returnType)));
+        });
+    }
+    convertInteropArgument(varName, type) {
+        const realInteropType = this.getNodeName(type);
+        let expr;
+        switch (realInteropType) {
+            case "KPointer":
+            case "KSerializerBuffer":
+                expr = `${varName}.toCPointer<CPointed>()!!`;
+                break;
+            case "KInt":
+            case "KLong":
+            case "KFloat":
+            case "KDouble":
+            case "KStringPtr":
+            case "KBoolean":
+            case "Float64":
+            case "Float":
+            case "Double":
+            case "UInt":
+            case "Int":
+                expr = varName;
+                break;
+            default: throw new Error(`Unexpected type ${realInteropType} in interop with Kotlin`);
+        }
+        return this.makeString(expr);
+    }
+    convertInteropReturnValue(varName, type) {
+        const realInteropType = this.getNodeName(type);
+        let expr;
+        switch (realInteropType) {
+            case "KPointer":
+                expr = `${varName}.toLong()`;
+                break;
+            case "KInt":
+            case "KLong":
+            case "Float64":
+            case "Float":
+            case "Double":
+            case "Long":
+            case "Int":
+                expr = varName;
+                break;
+            case "String":
+            case "KStringPtr":
+                expr = `${varName}?.toKString() ?: ""`;
+                break;
+            case "Boolean":
+            case "KBoolean":
+                expr = `${varName} != 0.toByte()`;
+                break;
+            case "KInteropReturnBuffer":
+                expr = `${varName}.useContents { KInteropReturnBuffer(length, data.toLong()) }`;
+                break;
+            default: throw new Error(`Unexpected type ${realInteropType} in interop with Kotlin`);
+        }
+        return this.makeString(expr);
     }
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, true, false, modifiers);
@@ -301,7 +386,7 @@ export class KotlinLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, modifiers, getter, setter) {
+    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let containerName = propName.concat("_container");
         let truePropName = this.escapeKeyword(propName);
         if (getter) {
@@ -309,9 +394,10 @@ export class KotlinLanguageWriter extends LanguageWriter {
                 this.print(`private var ${containerName}: ${this.getNodeName(propType)}`);
             }
         }
-        let isStatic = modifiers.includes(FieldModifier.STATIC);
         let isMutable = !modifiers.includes(FieldModifier.READONLY);
-        this.print(`public ${isMutable ? "var " : "val "}${truePropName}: ${this.getNodeName(propType)}`);
+        let isOverride = modifiers.includes(FieldModifier.OVERRIDE);
+        let initializer = initExpr ? ` = ${initExpr.asString()}` : "";
+        this.print(`${isOverride ? 'override ' : ''}public ${isMutable ? "var " : "val "}${truePropName}: ${this.getNodeName(propType)}${initializer}`);
         if (getter) {
             this.pushIndent();
             this.writeGetterImplementation(getter.method, getter.op);
@@ -363,10 +449,10 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return new KotlinThrowErrorStatement(message);
     }
     makeReturn(expr) {
-        return new TSReturnStatement(expr);
+        return new ReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        throw new Error("Not implemented");
+    makeLambdaReturn(expr) {
+        return new KotlinLambdaReturnStatement(expr);
     }
     makeStatement(expr) {
         return new ExpressionStatement(expr);
@@ -378,7 +464,7 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return new KotlinMapForEachStatement(map, key, value, op);
     }
     writePrintLog(message) {
-        throw new Error("Not implemented");
+        this.print(`println(\"${message}\")`);
     }
     makeCast(value, node, options) {
         return this.makeString(`${value.asString()} as ${this.getNodeName(node)}`);
@@ -398,12 +484,18 @@ export class KotlinLanguageWriter extends LanguageWriter {
     makeTupleAlloc(option) {
         throw new Error("Not implemented");
     }
+    makeTupleAccess(value, index) {
+        return this.makeString(`${value}.component${index + 1}()`);
+    }
     makeArrayInit(type, size) {
-        return this.makeString(`Array<${this.getNodeName(type.elementType[0])}>(${size !== null && size !== void 0 ? size : ''})`);
+        return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(${size !== null && size !== void 0 ? size : ''})`);
     }
     makeArrayLength(array, length) {
         return this.makeString(`${array}.size`);
     }
+    makeArrayResize(array, arrayType, length, deserializer) {
+        return new KotlinArrayResizeStatement(array, arrayType, length, deserializer);
+    }
     makeClassInit(type, paramenters) {
         throw new Error("Not implemented");
     }
@@ -411,13 +503,13 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return this.makeString(`${this.getNodeName(type)}()`);
     }
     makeMapInsert(keyAccessor, key, valueAccessor, value) {
-        return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
+        return this.makeStatement(this.makeMethodCall(keyAccessor, "put", [this.makeString(key), this.makeString(value)]));
     }
     makeUnwrapOptional(expression) {
         return new KotlinUnwrapOptionalExpression(expression);
     }
     makeDefinedCheck(value) {
-        return new KotlinCheckDefinedExpression(value);
+        return this.makeString(`${value} != null`);
     }
     makeUnionSelector(value, valueType) {
         return this.makeAssign(valueType, undefined, this.makeMethodCall(value, "getSelector", []), false);
@@ -453,13 +545,13 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.OVERRIDE];
     }
     get supportedFieldModifiers() {
-        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY];
+        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.OVERRIDE];
     }
     enumFromI32(value, enumEntry) {
         return this.makeString(`${this.getNodeName(enumEntry)}(${value.asString()})`);
     }
     i32FromEnum(value, enumEntry) {
-        return this.makeString(`${value.asString()}.value`);
+        return this.makeString(`${value.asString()}.value!!`);
     }
     makeEnumEntity(enumEntity, options) {
         return new KotlinEnumWithGetter(enumEntity, options.isExport);
@@ -479,9 +571,6 @@ export class KotlinLanguageWriter extends LanguageWriter {
     escapeKeyword(keyword) {
         return keyword;
     }
-    makeDiscriminatorConvertor(convertor, value, index) {
-        throw new Error("Not implemented");
-    }
     makeStaticBlock(op) {
         this.printer.print('companion object {');
         this.printer.pushIndent();