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

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;
@@ -76,6 +78,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     writePrintLog(message: string): void;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
+    instanceOf(value: string, type: idl.IDLType): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
@@ -98,5 +101,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;
     discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
+    private writingClassBody;
+    classOp(op: () => void): void;
 }
 //# sourceMappingURL=TsLanguageWriter.d.ts.map

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

@@ -16,7 +16,7 @@ import * as idl from '../../idl';
 import { isOptionalType } from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { ACCESS_MODIFIERS_SET, AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { rightmostIndexOf } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
@@ -67,7 +67,7 @@ class TSThrowErrorStatement {
         this.message = message;
     }
     write(writer) {
-        writer.print(`throw new Error("${this.message}")`);
+        writer.print(`throw new Error('${this.message}')`);
     }
 }
 export class TSReturnStatement extends ReturnStatement {
@@ -121,6 +121,7 @@ export class TsTupleAllocStatement {
 export class TSLanguageWriter extends LanguageWriter {
     constructor(printer, resolver, typeConvertor, language = Language.TS) {
         super(printer, resolver, language);
+        this.writingClassBody = false;
         this.typeConvertor = typeConvertor;
     }
     maybeSemicolon() { return ""; }
@@ -148,6 +149,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(",")}` : '';
@@ -156,7 +160,7 @@ export class TSLanguageWriter extends LanguageWriter {
         let abstractClause = isAbstract ? ` abstract` : '';
         this.printer.print(`export${declaredClause}${abstractClause} class ${name}${genericsClause}${extendsClause}${implementsClause} {`);
         this.pushIndent();
-        op(this);
+        this.classOp(() => op(this));
         this.popIndent();
         this.printer.print(`}`);
     }
@@ -198,7 +202,7 @@ export class TSLanguageWriter extends LanguageWriter {
                 value = member.alias;
             }
             else {
-                value = `${member.stringId != undefined ? `"${member.stringId}"` : `${member.numberId}`}`;
+                value = `${member.stringId != undefined ? `'${member.stringId}'` : `${member.numberId}`}`;
             }
             const maybeComma = index < members.length - 1 ? "," : "";
             this.printer.print(`${member.name} = ${value}${maybeComma}`);
@@ -207,11 +211,27 @@ export class TSLanguageWriter extends LanguageWriter {
         this.printer.print("}");
     }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
-        const init = initExpr != undefined ? ` = ${initExpr.asString()}` : ``;
+        var _a;
+        if (this.writingClassBody && !(modifiers === null || modifiers === void 0 ? void 0 : modifiers.some(m => ACCESS_MODIFIERS_SET.has(m)))) {
+            modifiers = (_a = modifiers === null || modifiers === void 0 ? void 0 : modifiers.slice()) !== null && _a !== void 0 ? _a : [];
+            modifiers.unshift(FieldModifier.PUBLIC);
+        }
         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 +268,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 +277,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 +298,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))
@@ -331,6 +360,11 @@ export class TSLanguageWriter extends LanguageWriter {
         var _a;
         return new TSCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
+    instanceOf(value, type) {
+        return idl.IDLContainerUtils.isSequence(type)
+            ? this.makeString(`Array.isArray(${value})`)
+            : super.instanceOf(value, type);
+    }
     typeInstanceOf(type, value, members) {
         if (idl.isInterface(type)) {
             if (idl.isInterfaceSubkind(type)) {
@@ -417,16 +451,22 @@ export class TSLanguageWriter extends LanguageWriter {
         }
         return this.makeString(`${value.asString()}.valueOf()`);
     }
-    castToBoolean(value) { return `+${value}`; }
+    castToBoolean(value) { return `!!${value}`; }
     makeCallIsObject(value) {
         return this.makeString(`${value} instanceof Object`);
     }
     escapeKeyword(keyword) {
-        return TSKeywords.has(keyword) ? keyword + "_" : keyword;
+        return TSKeywords.has(keyword) ? keyword + "Val" : keyword;
     }
     discriminate(value, index, type, runtimeTypes) {
         const runtimeTypeList = runtimeTypes.map(ty => "RuntimeType." + RuntimeType[ty]).join(", ");
         return `[${runtimeTypeList}].includes(runtimeType(${value}))`;
     }
+    classOp(op) {
+        const old = this.writingClassBody;
+        this.writingClassBody = true;
+        op();
+        this.writingClassBody = old;
+    }
 }
 //# sourceMappingURL=TsLanguageWriter.js.map

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;