@idlizer/core 2.1.10-arktscgen-3a → 2.1.10-arktscgen-5

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

@@ -127,6 +127,9 @@ export class TSLanguageWriter extends LanguageWriter {
     pushNamespace(namespace, options) {
         this.namespaceStack.push(namespace);
         const declaredPrefix = options.isDeclared ? "declare " : "";
+        if (options.isDefault) {
+            this.print(`export default ${namespace}`);
+        }
         this.print(`export ${declaredPrefix}namespace ${namespace} {`);
         if (options.ident)
             this.pushIndent();
@@ -145,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(",")}` : '';
@@ -204,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;
@@ -245,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) {
@@ -255,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;
@@ -276,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;