@idlizer/core 2.1.10-arktscgen-4 → 2.1.10-arktscgen-5

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

@@ -5,26 +5,22 @@ import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolv
 import { CJIDLTypeToForeignStringConvertor, CJInteropArgConvertor, CJTypeNameConvertor } from "./convertors/CJConvertors";
 import { CppInteropArgConvertor, CppConvertor } from "./convertors/CppConvertors";
 import { ETSInteropArgConvertor, ETSTypeNameConvertor } from "./convertors/ETSConvertors";
-import { JavaInteropArgConvertor, JavaTypeNameConvertor } from "./convertors/JavaConvertors";
-import { KotlinTypeNameConvertor } from "./convertors/KotlinConvertors";
+import { KotlinCInteropArgConvertor, KotlinTypeNameConvertor } from "./convertors/KotlinConvertors";
 import { TSInteropArgConvertor, TSTypeNameConvertor } from "./convertors/TSConvertors";
 import { CJLanguageWriter } from "./writers/CJLanguageWriter";
 import { CppLanguageWriter } from "./writers/CppLanguageWriter";
 import { ETSLanguageWriter } from "./writers/ETSLanguageWriter";
-import { JavaLanguageWriter } from "./writers/JavaLanguageWriter";
 import { KotlinLanguageWriter } from "./writers/KotlinLanguageWriter";
 import { TSLanguageWriter } from "./writers/TsLanguageWriter";
 export * from "./nameConvertor";
-export function createLanguageWriter(language, resolver) {
-    resolver !== null && resolver !== void 0 ? resolver : (resolver = EmptyReferenceResolver);
+export function createLanguageWriter(language, library) {
     const printer = new IndentedPrinter();
     switch (language) {
-        case Language.TS: return new TSLanguageWriter(printer, resolver, new TSTypeNameConvertor(resolver));
-        case Language.ARKTS: return new ETSLanguageWriter(printer, resolver, new ETSTypeNameConvertor(resolver), new CppConvertor(resolver));
-        case Language.JAVA: return new JavaLanguageWriter(printer, resolver, new JavaTypeNameConvertor(resolver));
-        case Language.CPP: return new CppLanguageWriter(printer, resolver, new CppConvertor(resolver), PrimitiveTypesInstance);
-        case Language.CJ: return new CJLanguageWriter(printer, resolver, new CJTypeNameConvertor(resolver), new CJIDLTypeToForeignStringConvertor(resolver));
-        case Language.KOTLIN: return new KotlinLanguageWriter(printer, resolver, new KotlinTypeNameConvertor(resolver));
+        case Language.TS: return new TSLanguageWriter(printer, library, new TSTypeNameConvertor(library));
+        case Language.ARKTS: return new ETSLanguageWriter(printer, library, new ETSTypeNameConvertor(library), new CppConvertor(library));
+        case Language.CPP: return new CppLanguageWriter(printer, library, new CppConvertor(library), PrimitiveTypesInstance);
+        case Language.CJ: return new CJLanguageWriter(printer, library, new CJTypeNameConvertor(library), new CJIDLTypeToForeignStringConvertor(library));
+        case Language.KOTLIN: return new KotlinLanguageWriter(printer, library, new KotlinTypeNameConvertor(library));
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
@@ -33,9 +29,8 @@ export function createInteropArgConvertor(language) {
         case Language.TS: return new TSInteropArgConvertor();
         case Language.ARKTS: return new ETSInteropArgConvertor();
         case Language.CPP: return CppInteropArgConvertor.INSTANCE;
-        case Language.JAVA: return new JavaInteropArgConvertor();
         case Language.CJ: return new CJInteropArgConvertor();
-        case Language.KOTLIN: return new CJInteropArgConvertor();
+        case Language.KOTLIN: return new KotlinCInteropArgConvertor();
     }
     throw new Error(`InteropArgConvertor for language ${language} not implemented`);
 }

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

@@ -75,6 +75,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     getNodeName(type: idl.IDLNode): string;
+    get interopModule(): string;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[]): void;
     writeEnum(name: string, members: {
         name: string;
@@ -105,6 +106,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     writeGetterImplementation(method: Method, op?: (writer: this) => void): void;
     writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
+    writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): void;
     private writeDeclaration;
     writeNativeFunctionCall(printer: LanguageWriter, name: string, signature: MethodSignature): void;
     writeNativeMethodDeclaration(method: Method): void;

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

@@ -16,7 +16,7 @@ import * as idl from "../../idl";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { CJKeywords } from "../../languageSpecificKeywords";
 import { RuntimeType } from "../common";
-import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, } from "../LanguageWriter";
 import { Language } from "../../Language";
 import { indentedBy, isDefined } from "../../util";
 ////////////////////////////////////////////////////////////////
@@ -255,6 +255,9 @@ export class CJLanguageWriter extends LanguageWriter {
         // rework for proper namespace logic
         return this.typeConvertor.convert(type);
     }
+    get interopModule() {
+        return "Interop";
+    }
     writeClass(name, op, superClass, interfaces, generics) {
         let extendsClause = superClass ? `${superClass}` : undefined;
         let implementsClause = interfaces ? `${interfaces.join(' & ')}` : undefined;
@@ -401,6 +404,15 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.print('}');
     }
+    writeImports(moduleName, importedFeatures, aliases) {
+        if (importedFeatures.length !== aliases.length) {
+            throw new Error(`Inconsistent imports from ${moduleName}`);
+        }
+        for (let i = 0; i < importedFeatures.length; i++) {
+            const alias = aliases[i] ? ` as ${aliases[i]}` : ``;
+            this.writeExpressionStatement(this.makeString(`import ${moduleName}.${importedFeatures[i]}` + alias));
+        }
+    }
     writeDeclaration(name, signature, modifiers, postfix, generics) {
         let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(it => this.supportedModifiers.includes(it)).map(it => this.mapMethodModifier(it)).join(" ");
         prefix = prefix ? prefix + " " : "public ";

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

@@ -47,6 +47,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
+    get interopModule(): string;
     protected writeDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[], postfix?: string): void;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[]): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
@@ -63,6 +64,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     }): void;
     writeTypeDeclaration(decl: IDLTypedef): void;
     writeConstant(constName: string, constType: IDLType, constVal?: string): void;
+    writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): void;
     /**
      * Writes multiline comments decorated with stars
      */

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

@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createReferenceType, forceAsNamedNode } from '../../idl';
+import { createReferenceType, forceAsNamedNode, } from '../../idl';
 import { Language } from '../../Language';
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
 import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, StringExpression, MethodStaticCallExpression } from "../LanguageWriter";
@@ -181,6 +181,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         var _a;
         return new CppLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
     }
+    get interopModule() {
+        throw new Error(`Modules are not supported in C++`);
+    }
     writeDeclaration(name, signature, modifiers, postfix) {
         const realName = this.classMode === 'normal' ? name : `${this.currentClass.at(0)}::${name}`;
         const newModifiers = this.classMode === 'normal'
@@ -253,6 +256,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     writeConstant(constName, constType, constVal) {
         this.print(`${this.getNodeName(constType)} ${constName}${constVal ? ' = ' + constVal : ''};`);
     }
+    writeImports(moduleName, importedFeatures, aliases) {
+        throw new Error(`Imports are not supported in C++`);
+    }
     /**
      * Writes multiline comments decorated with stars
      */

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

@@ -1,5 +1,5 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, NamespaceOptions } 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";
@@ -45,7 +45,6 @@ export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName:
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, arrayConvertor: IdlNameConvertor);
-    pushNamespace(namespace: string, options: NamespaceOptions): void;
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;

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

@@ -175,9 +175,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         super(printer, resolver, typeConvertor, Language.ARKTS);
         this.arrayConvertor = arrayConvertor;
     }
-    pushNamespace(namespace, options) {
-        super.pushNamespace(namespace, options);
-    }
     fork(options) {
         var _a;
         return new ETSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);

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

@@ -29,6 +29,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
+    get interopModule(): string;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
@@ -44,6 +45,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     }, initExpr?: LanguageExpression): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
+    writeImports(moduleName: string, importedFeatures: string[], aliases: 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;

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

@@ -105,6 +105,9 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         var _a;
         return new JavaLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor);
     }
+    get interopModule() {
+        return "org.koalaui.interop";
+    }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isExport = true) {
         let genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(', ')}> ` : ``;
         let extendsClause = superClass ? ` extends ${superClass}` : '';
@@ -179,6 +182,14 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     writeConstant(constName, constType, constVal) {
         throw new Error("writeConstant for Java is not implemented yet.");
     }
+    writeImports(moduleName, importedFeatures, aliases) {
+        if (importedFeatures.length !== aliases.length) {
+            throw new Error(`Inconsistent imports from ${moduleName}`);
+        }
+        for (let i = 0; i < importedFeatures.length; i++) {
+            this.writeExpressionStatement(this.makeString(`import ${moduleName}.${importedFeatures[i]}`));
+        }
+    }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
         return new JavaAssignStatement(variableName, type, expr, isDeclared, isConst);
     }

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

@@ -61,6 +61,8 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     getNodeName(type: idl.IDLNode): string;
+    get interopModule(): string;
+    maybeSemicolon(): string;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isAbstract?: boolean): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
     writeFunctionDeclaration(name: string, signature: MethodSignature, generics?: string[]): void;
@@ -78,6 +80,11 @@ 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 printForeignApiOptIn;
+    private get foreignApiOptIn();
+    private isPrimitiveArray;
+    private pinArrayArgument;
+    private unpinArrayArgument;
     private convertInteropArgument;
     private convertInteropReturnValue;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
@@ -94,6 +101,7 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
+    writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): void;
     makeNull(): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;

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

@@ -15,10 +15,10 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, ReturnStatement } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, ReturnStatement, } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { isDefined } from "../../util";
-import { removePoints } from '../convertors/CJConvertors';
+import { removePoints } from '../../util';
 export class KotlinLambdaReturnStatement {
     constructor(expression) {
         this.expression = expression;
@@ -87,7 +87,7 @@ export class KotlinEnumWithGetter {
             const enumType = idl.createReferenceType(this.enumEntity);
             writer.makeStaticBlock(() => {
                 members.forEach(it => {
-                    writer.writeFieldDeclaration(it.name, idl.IDLAnyType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.FINAL], false, writer.makeString(`${mangledName}(${it.stringId ? `\"${it.stringId}\"` : it.numberId})`));
+                    writer.writeFieldDeclaration(it.name, enumType, [FieldModifier.PUBLIC, FieldModifier.STATIC, FieldModifier.FINAL], false, writer.makeString(`${mangledName}(${it.stringId ? `\"${it.stringId}\"` : it.numberId})`));
                 });
             });
             const value = 'value';
@@ -230,6 +230,10 @@ export class KotlinLanguageWriter extends LanguageWriter {
         }
         return this.typeConvertor.convert(type);
     }
+    get interopModule() {
+        return "koalaui.interop";
+    }
+    maybeSemicolon() { return ""; }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? `${superClass}` : undefined;
         let implementsClause = interfaces ? `${interfaces.join(' , ')}` : undefined;
@@ -293,32 +297,75 @@ export class KotlinLanguageWriter extends LanguageWriter {
         let name = method.name;
         let signature = method.signature;
         this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => {
+            const pins = signature.args.flatMap((type, index) => this.pinArrayArgument(signature.argName(index), type));
+            const unpins = signature.args.flatMap((type, index) => this.unpinArrayArgument(signature.argName(index), type));
+            pins.filter(it => !!it).forEach(it => this.writeStatement(it));
             const args = signature.args.map((type, index) => this.convertInteropArgument(signature.argName(index), type));
+            this.printForeignApiOptIn();
             const interopCallExpression = this.makeFunctionCall(`kotlin${name}`, args);
             if (signature.returnType === idl.IDLVoidType) {
                 this.writeExpressionStatement(interopCallExpression);
+                unpins.filter(it => !!it).forEach(it => this.writeStatement(it));
                 return;
             }
             const retval = "retval";
             this.writeStatement(this.makeAssign(retval, undefined, interopCallExpression));
+            unpins.filter(it => !!it).forEach(it => this.writeStatement(it));
+            this.printForeignApiOptIn();
             this.writeStatement(this.makeReturn(this.convertInteropReturnValue(retval, signature.returnType)));
         });
     }
+    printForeignApiOptIn() {
+        this.writeStatement(this.foreignApiOptIn);
+    }
+    get foreignApiOptIn() {
+        return new ExpressionStatement(this.makeString("@OptIn(ExperimentalForeignApi::class)"));
+    }
+    isPrimitiveArray(type) {
+        if (!idl.IDLContainerUtils.isSequence(type)) {
+            return false;
+        }
+        const elementType = type.elementType[0];
+        const allowedTypes = [idl.IDLU8Type, idl.IDLI32Type, idl.IDLF32Type];
+        return allowedTypes.includes(elementType);
+    }
+    pinArrayArgument(varName, type) {
+        if (this.isPrimitiveArray(type)) {
+            const pinCall = this.makeMethodCall(varName, "pin", []);
+            const assign = this.makeAssign(`${varName}Pinned`, undefined, pinCall, true, true);
+            return [this.foreignApiOptIn, assign];
+        }
+        return [];
+    }
+    unpinArrayArgument(varName, type) {
+        if (this.isPrimitiveArray(type)) {
+            const call = new ExpressionStatement(this.makeMethodCall(`${varName}Pinned`, "unpin", []));
+            return [this.foreignApiOptIn, call];
+        }
+        return [];
+    }
     convertInteropArgument(varName, type) {
         const realInteropType = this.getNodeName(type);
         let expr;
         switch (realInteropType) {
+            case "UByteArray":
+            case "IntArray":
+            case "FloatArray":
+                expr = `${varName}Pinned.addressOf(0)`;
+                break;
             case "KPointer":
+            case "KNativePointer":
             case "KSerializerBuffer":
                 expr = `${varName}.toCPointer<CPointed>()!!`;
                 break;
+            case "BigInteger":
             case "KInt":
             case "KLong":
             case "KFloat":
             case "KDouble":
+            case "String":
             case "KStringPtr":
             case "KBoolean":
-            case "Float64":
             case "Float":
             case "Double":
             case "UInt":
@@ -333,12 +380,13 @@ export class KotlinLanguageWriter extends LanguageWriter {
         const realInteropType = this.getNodeName(type);
         let expr;
         switch (realInteropType) {
+            case "KNativePointer":
             case "KPointer":
                 expr = `${varName}.toLong()`;
                 break;
             case "KInt":
             case "KLong":
-            case "Float64":
+            case "BigInteger":
             case "Float":
             case "Double":
             case "Long":
@@ -389,30 +437,21 @@ export class KotlinLanguageWriter extends LanguageWriter {
     writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let containerName = propName.concat("_container");
         let truePropName = this.escapeKeyword(propName);
-        if (getter) {
-            if (!getter.op) {
-                this.print(`private var ${containerName}: ${this.getNodeName(propType)}`);
-            }
-        }
-        let isMutable = !modifiers.includes(FieldModifier.READONLY);
+        const isReadonly = modifiers.includes(FieldModifier.READONLY);
+        const isGetter = modifiers.includes(FieldModifier.GET);
+        const isSetter = modifiers.includes(FieldModifier.SET);
+        const isImmutable = isReadonly || (isGetter && !isSetter);
         let isOverride = modifiers.includes(FieldModifier.OVERRIDE);
         let initializer = initExpr ? ` = ${initExpr.asString()}` : "";
-        this.print(`${isOverride ? 'override ' : ''}public ${isMutable ? "var " : "val "}${truePropName}: ${this.getNodeName(propType)}${initializer}`);
+        this.print(`${isOverride ? 'override ' : ''}public ${isImmutable ? "val " : "var "}${truePropName}: ${this.getNodeName(propType)}${initializer}`);
         if (getter) {
             this.pushIndent();
             this.writeGetterImplementation(getter.method, getter.op);
-            if (isMutable) {
-                if (setter) {
-                    this.writeSetterImplementation(setter.method, setter ? setter.op : (writer) => { this.print(`${containerName} = ${truePropName}`); });
-                }
-                else {
-                    this.print(`set(${truePropName}) {`);
-                    this.pushIndent();
-                    this.print(`${containerName} = ${truePropName}`);
-                    this.popIndent();
-                    this.print(`}`);
-                }
-            }
+            this.popIndent();
+        }
+        if (setter) {
+            this.pushIndent();
+            this.writeSetterImplementation(setter.method, setter ? setter.op : (writer) => { writer.print(`${containerName} = ${truePropName}`); });
             this.popIndent();
         }
     }
@@ -434,7 +473,16 @@ export class KotlinLanguageWriter extends LanguageWriter {
         throw new Error("Not implemented");
     }
     writeConstant(constName, constType, constVal) {
-        throw new Error("Not implemented");
+        this.print(`val ${constName} = ${constVal}`);
+    }
+    writeImports(moduleName, importedFeatures, aliases) {
+        if (importedFeatures.length !== aliases.length) {
+            throw new Error(`Inconsistent imports from ${moduleName}`);
+        }
+        for (let i = 0; i < importedFeatures.length; i++) {
+            const alias = aliases[i] ? ` as ${aliases[i]}` : ``;
+            this.writeExpressionStatement(this.makeString(`import ${moduleName}.${importedFeatures[i]}` + alias));
+        }
     }
     makeNull() {
         return this.makeString('null');
@@ -529,14 +577,14 @@ export class KotlinLanguageWriter extends LanguageWriter {
         }
         else {
             const op = equals ? "==" : "!=";
-            return this.makeNaryOp(op, [this.makeRuntimeType(type), this.makeString(`${typeVarName}.toInt()`)]);
+            return this.makeNaryOp(op, [this.makeRuntimeType(type), this.makeString(`${typeVarName}`)]);
         }
     }
     getTagType() {
         return idl.createReferenceType("Tag");
     }
     getRuntimeType() {
-        return idl.IDLNumberType;
+        return idl.IDLI8Type;
     }
     makeTupleAssign(receiver, fields) {
         throw new Error("Not implemented");

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

@@ -37,6 +37,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     getNodeName(type: idl.IDLNode): string;
+    get interopModule(): string;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isAbstract?: boolean): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
     writeFunctionDeclaration(name: string, signature: MethodSignature, generics?: string[]): void;
@@ -65,6 +66,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     }, initExpr?: LanguageExpression): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
+    writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): void;
     private writeDeclaration;
     makeNull(type?: idl.IDLOptionalType): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;

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

@@ -148,6 +148,9 @@ export class TSLanguageWriter extends LanguageWriter {
         }
         return this.typeConvertor.convert(type);
     }
+    get interopModule() {
+        return "@koalaui/interop";
+    }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? ` extends ${superClass}` : '';
         let implementsClause = interfaces ? ` implements ${interfaces.join(",")}` : '';
@@ -207,11 +210,22 @@ export class TSLanguageWriter extends LanguageWriter {
         this.printer.print("}");
     }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
-        const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
         let prefix = this.makeFieldModifiersList(modifiers);
         if (prefix)
             prefix += " ";
-        this.printer.print(`${prefix}${name}${optional ? "?" : ""}: ${this.getNodeName(type)}${init}`);
+        const typeName = this.getNodeName(type);
+        const isGetter = modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(FieldModifier.GET);
+        const isSetter = modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(FieldModifier.SET);
+        if (isGetter) {
+            this.printer.print(`${prefix}get ${name}(): ${typeName}`);
+        }
+        if (isSetter) {
+            this.printer.print(`${prefix}set ${name}(value: ${typeName})`);
+        }
+        if (isGetter || isSetter)
+            return;
+        const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
+        this.printer.print(`${prefix}${name}${optional ? "?" : ""}: ${typeName}${init}`);
     }
     writeNativeMethodDeclaration(method) {
         let name = method.name;
@@ -248,7 +262,6 @@ export class TSLanguageWriter extends LanguageWriter {
     }
     writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let isStatic = modifiers.includes(FieldModifier.STATIC);
-        let isMutable = !modifiers.includes(FieldModifier.READONLY);
         let containerName = propName.concat("_container");
         if (getter) {
             if (!getter.op) {
@@ -258,17 +271,17 @@ export class TSLanguageWriter extends LanguageWriter {
                 (writer) => {
                     writer.print(`return ${containerName}`);
                 });
-            if (isMutable) {
-                const setSignature = new NamedMethodSignature(idl.IDLVoidType, [propType], [propName]);
-                this.writeSetterImplementation(new Method(propName, setSignature, isStatic ? [MethodModifier.STATIC] : []), setter ? setter.op :
-                    (writer) => {
-                        writer.print(`${containerName} = ${propName}`);
-                    });
-            }
         }
-        else {
-            this.writeFieldDeclaration(propName, propType, modifiers, idl.isOptionalType(propType), initExpr);
+        if (setter) {
+            const setSignature = new NamedMethodSignature(idl.IDLVoidType, [propType], [propName]);
+            this.writeSetterImplementation(new Method(propName, setSignature, isStatic ? [MethodModifier.STATIC] : []), setter ? setter.op :
+                (writer) => {
+                    writer.print(`${containerName} = ${propName}`);
+                });
         }
+        if (getter || setter)
+            return;
+        this.writeFieldDeclaration(propName, propType, modifiers, idl.isOptionalType(propType), initExpr);
     }
     writeTypeDeclaration(decl) {
         var _a;
@@ -279,6 +292,16 @@ export class TSLanguageWriter extends LanguageWriter {
     writeConstant(constName, constType, constVal) {
         this.print(`export const ${constName}: ${this.getNodeName(constType)}${constVal ? ' = ' + constVal : ''}`);
     }
+    writeImports(moduleName, importedFeatures, aliases) {
+        if (importedFeatures.length !== aliases.length) {
+            throw new Error(`Inconsistent imports from ${moduleName}`);
+        }
+        const importNodes = [];
+        for (let i = 0; i < importedFeatures.length; i++) {
+            importNodes.push(importedFeatures[i] + (aliases[i] ? ` as ${aliases[i]}` : ``));
+        }
+        this.writeExpressionStatement(this.makeString(`import { ${importNodes.join(', ')} } from "${moduleName}"`));
+    }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
         let prefix = !modifiers ? undefined : this.supportedModifiers
             .filter(it => modifiers.includes(it))

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

@@ -9,7 +9,6 @@ export interface LibraryInterface extends ReferenceResolver {
     get files(): idl.IDLFile[];
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
-    getInteropName(node: idl.IDLNode): string;
     createTypeNameConvertor(language: Language): IdlNameConvertor;
     createContinuationCallbackReference(continuationType: idl.IDLType): idl.IDLReferenceType;
     getCurrentContext(): string | undefined;

package/build/lib/src/from-idl/DtsPrinter.js

@@ -17,7 +17,7 @@ import { IDLEntity, IDLKind, getExtAttribute, getVerbatimDts, hasExtAttribute, i
 import { resolveSyntheticType, parseIDLFile } from "./deserialize";
 import { Language } from "../Language";
 import { warn } from "../util";
-import { isInIdlize } from "../idlize";
+import { isInIdlize } from "../idl";
 export class CustomPrintVisitor {
     constructor(resolver, language) {
         this.resolver = resolver;

package/build/lib/src/from-idl/deserialize.js

@@ -531,7 +531,7 @@ export function toIdlType(fileName, content) {
     return deserializer.toIDLType(fileName, webidl2.parseType(content, fileName));
 }
 const DifferenceFound = new DiagnosticMessageGroup("error", "DifferenceFound", "Difference found");
-const noCompare = new Set(["parent", "fileName", "nodeLocation", "nameLocation", "valueLocation", "typesValue"]);
+const noCompare = new Set(["parent", "fileName", "nodeLocation", "nameLocation", "valueLocation", "typesValue", "text"]);
 const canContainMoreCompare = new Set(["extendedAttributes", "typeParameters", "typeArguments"]);
 function safeString(value) {
     if (typeof value == "symbol") {

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

@@ -435,5 +435,10 @@ export declare function extremumOfOrdinals(enumEntry: IDLEnum): {
     low: number;
     high: number;
 };
+export declare const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
+export declare function isInIdlize(entry: IDLEntry | IDLFile): boolean;
+export declare function isInIdlizeInterop(entry: IDLEntry | IDLFile): boolean;
+export declare function isInIdlizeInternal(entry: IDLEntry | IDLFile): boolean;
+export declare function isInIdlizeStdlib(entry: IDLEntry | IDLFile): boolean;
 export {};
 //# sourceMappingURL=idl.d.ts.map

package/build/lib/src/idl.js

@@ -482,6 +482,7 @@ export function getNamespacesPathFor(node) {
     }
     return result;
 }
+const nodesWithoutIDLFiles = new Set();
 export function getFileFor(node) {
     let iterator = node;
     while (iterator) {
@@ -489,7 +490,11 @@ export function getFileFor(node) {
             return iterator;
         iterator = iterator.parent;
     }
-    console.warn(`Node ${getQualifiedName(node, "namespace.name")} does not have IDLFile in parents`);
+    const name = getQualifiedName(node, "namespace.name");
+    if (!nodesWithoutIDLFiles.has(name)) {
+        console.warn(`Node ${name} does not have IDLFile in parents`);
+        nodesWithoutIDLFiles.add(name);
+    }
     return undefined;
 }
 export function isEqualByQualifedName(a, b, pattern = "package.namespace.name") {
@@ -1364,4 +1369,17 @@ export function extremumOfOrdinals(enumEntry) {
     });
     return { low, high };
 }
+export const PACKAGE_IDLIZE_INTERNAL = "idlize.internal";
+export function isInIdlize(entry) {
+    return isInPackage(entry, "idlize");
+}
+export function isInIdlizeInterop(entry) {
+    return isInPackage(entry, `${PACKAGE_IDLIZE_INTERNAL}.interop`);
+}
+export function isInIdlizeInternal(entry) {
+    return isInPackage(entry, PACKAGE_IDLIZE_INTERNAL);
+}
+export function isInIdlizeStdlib(entry) {
+    return isInPackage(entry, "idlize.stdlib");
+}
 //# sourceMappingURL=idl.js.map