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

package/build/lib/src/LanguageWriters/convertors/TSConvertors.js

@@ -13,11 +13,26 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { Language } from '../../Language';
+import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
+import { isDeclaredInCurrentFile, LayoutNodeRole } from '../../peer-generation/LayoutManager';
 import { maybeRestoreGenerics } from '../../transformers/GenericTransformer';
 import { convertNode, convertType } from '../nameConvertor';
 export class TSTypeNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
+    constructor(library) {
+        this.library = library;
+    }
+    mangleTopLevel(decl) {
+        if (!isDeclaredInCurrentFile(this.library.layout, { node: decl, role: LayoutNodeRole.INTERFACE }) && isTopLevelConflicted(this.library, Language.TS, decl)) {
+            const namespaces = idl.getNamespacesPathFor(decl);
+            if (namespaces.length === 0) {
+                return idl.getQualifiedName(decl, "package.namespace.name").replaceAll('.', '_');
+            }
+            const [rootNamespace, ...otherNamespaces] = idl.getNamespacesPathFor(decl);
+            const mangledRoot = idl.getQualifiedName(rootNamespace, "package.namespace.name").replaceAll('.', '_');
+            return [mangledRoot, ...otherNamespaces, decl.name].join(".");
+        }
+        return undefined;
     }
     convert(node) {
         return convertNode(this, node);
@@ -26,18 +41,22 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return idl.getQualifiedName(node, "namespace.name");
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertEnum(node) {
-        return idl.getQualifiedName(node, "namespace.name");
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertTypedef(node) {
-        return node.name;
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertCallback(node) {
+        var _a;
         return idl.isSyntheticEntry(node)
             ? this.mapCallback(node)
-            : node.name;
+            : (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : node.name;
     }
     convertMethod(node) {
         return node.name;
@@ -90,14 +109,14 @@ export class TSTypeNameConvertor {
     convertTypeReferenceAsImport(type, importClause) {
         var _a;
         const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) ? `<${type.typeArguments.join(', ')}>` : "";
-        let decl = this.resolver.resolveTypeReference(type);
+        let decl = this.library.resolveTypeReference(type);
         if (decl)
             return `${decl.name}${maybeTypeArguments}`;
         return `${type.name}${maybeTypeArguments}`;
     }
     convertTypeReference(type) {
-        var _a, _b;
-        let decl = this.resolver.resolveTypeReference(type);
+        var _a, _b, _c;
+        let decl = this.library.resolveTypeReference(type);
         if (decl) {
             if (idl.isSyntheticEntry(decl)) {
                 if (idl.isCallback(decl)) {
@@ -116,10 +135,10 @@ export class TSTypeNameConvertor {
                 // (can not cast MyEnum to exact MyEnum.Value1)
                 decl = decl.parent;
             }
-            let maybeRestoredGeneric = maybeRestoreGenerics(type, this.resolver);
+            let maybeRestoredGeneric = maybeRestoreGenerics(type, this.library);
             if (maybeRestoredGeneric) {
                 type = maybeRestoredGeneric;
-                decl = this.resolver.resolveTypeReference(maybeRestoredGeneric);
+                decl = this.library.resolveTypeReference(maybeRestoredGeneric);
             }
             let typeSpec = type.name;
             let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : [];
@@ -131,7 +150,7 @@ export class TSTypeNameConvertor {
             if (decl) {
                 const path = idl.getNamespacesPathFor(decl).map(it => it.name);
                 path.push(decl.name);
-                return `${path.join(".")}${maybeTypeArguments}`;
+                return `${(_c = this.mangleTopLevel(decl)) !== null && _c !== void 0 ? _c : path.join(".")}${maybeTypeArguments}`;
             }
             return `${type.name}${maybeTypeArguments}`;
         }
@@ -192,27 +211,16 @@ export class TSTypeNameConvertor {
         }
         return subst;
     }
-    applySubstitution(subst, type) {
-        var _a;
-        if (idl.isContainerType(type)) {
-            return idl.createContainerType(type.containerKind, type.elementType.map(it => this.applySubstitution(subst, it)));
-        }
-        if (idl.isReferenceType(type)) {
-            return idl.createReferenceType(type.name, (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.applySubstitution(subst, it)));
-        }
-        if (idl.isTypeParameterType(type)) {
-            const record = subst.get(type.name);
-            if (record) {
-                return record;
-            }
-        }
-        return type;
-    }
     mapCallback(decl, args) {
         const subst = this.createTypeSubstitution(decl.typeParameters, args);
         const parameters = decl.parameters.map(it => {
+            if (subst.size == 0)
+                return it;
             const param = idl.clone(it);
-            param.type = this.applySubstitution(subst, param.type);
+            param.parent = it.parent;
+            const type = applySubstitution(subst, param.type);
+            updateParent(param, type);
+            param.type = type;
             return param;
         });
         const params = parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}${it.isVariadic ? "[]" : ""}`);
@@ -223,8 +231,13 @@ export class TSTypeNameConvertor {
         const name = `${isTuple ? "[" : "{"} ${decl.properties
             .map(it => isTuple ? this.processTupleType(it) : it)
             .map(it => {
+            if (subst.size == 0)
+                return it;
             const prop = idl.clone(it);
-            prop.type = this.applySubstitution(subst, prop.type);
+            prop.parent = it.parent;
+            const type = applySubstitution(subst, prop.type);
+            updateParent(prop, type);
+            prop.type = type;
             return prop;
         })
             .map(it => {
@@ -287,4 +300,34 @@ export class TSInteropArgConvertor {
         throw new Error("Cannot pass union types through interop");
     }
 }
+function applySubstitution(subst, type) {
+    var _a;
+    if (idl.isContainerType(type)) {
+        return idl.createContainerType(type.containerKind, type.elementType.map(it => applySubstitution(subst, it)));
+    }
+    if (idl.isReferenceType(type)) {
+        return idl.createReferenceType(type.name, (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => applySubstitution(subst, it)));
+    }
+    if (idl.isTypeParameterType(type)) {
+        const record = subst.get(type.name);
+        if (record) {
+            return record;
+        }
+    }
+    return type;
+}
+// Update parents to properly find a file for conflicted types
+function updateParent(parent, type) {
+    type.parent = parent;
+    if (idl.isOptionalType(type))
+        updateParent(type, type.type);
+    if (idl.isUnionType(type))
+        updateParents(type, type.types);
+    if (idl.isContainerType(type))
+        updateParents(type, type.elementType);
+}
+function updateParents(parent, types) {
+    for (const type of types)
+        updateParent(parent, type);
+}
 //# sourceMappingURL=TSConvertors.js.map

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

@@ -1,8 +1,8 @@
 import { Language } from "../Language";
-import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { LibraryInterface } from "../LibraryInterface";
 import { LanguageWriter } from "./LanguageWriter";
 import { TypeConvertor } from "./nameConvertor";
 export * from "./nameConvertor";
-export declare function createLanguageWriter(language: Language, resolver?: ReferenceResolver): LanguageWriter;
+export declare function createLanguageWriter(language: Language, library: LibraryInterface): LanguageWriter;
 export declare function createInteropArgConvertor(language: Language): TypeConvertor<string>;
 //# sourceMappingURL=index.d.ts.map

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;
@@ -158,6 +160,8 @@ export declare class CJLanguageWriter extends LanguageWriter {
     popNamespace(options: {
         ident: boolean;
     }): void;
+    instanceOf(value: string, type: idl.IDLType): LanguageExpression;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
 }

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;
@@ -324,21 +327,6 @@ export class CJLanguageWriter extends LanguageWriter {
         this.writeDeclaration(name, signature, modifiers);
     }
     writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
-        var _a;
-        let i = 1;
-        while (signature.isArgOptional(signature.args.length - i)) {
-            let smallerSignature = signature.args.slice(0, -i);
-            this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}init(${smallerSignature.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}) {`);
-            this.pushIndent();
-            let lessArgs = (_a = signature.args) === null || _a === void 0 ? void 0 : _a.slice(0, -i).map((_, i) => this.escapeKeyword(signature.argName(i))).join(', ');
-            for (let idx = 0; idx < i; idx++) {
-                lessArgs = lessArgs.concat(`${i == signature.args.length && idx == 0 ? '' : ', '}Option.None`);
-            }
-            this.print(`this(${lessArgs})`);
-            this.popIndent();
-            this.printer.print(`}`);
-            i += 1;
-        }
         this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}init(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(idl.maybeOptional(it, signature.isArgOptional(index)))}`).join(", ")}) {`);
         this.pushIndent();
         if (delegationCall) {
@@ -416,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 ";
@@ -574,6 +571,17 @@ export class CJLanguageWriter extends LanguageWriter {
     }
     pushNamespace(namespace, options) { }
     popNamespace(options) { }
+    instanceOf(value, type) {
+        return this.makeString(`${value} is ${this.getNodeName(type)}`);
+    }
+    discriminate(value, index, type, runtimeTypes) {
+        if (runtimeTypes.includes(RuntimeType.UNDEFINED)) {
+            return `${value}.isNone()`;
+        }
+        else {
+            return `${value}.getSelector() == ${index}`;
+        }
+    }
     castToInt(value, bitness) {
         return `Int${bitness}(${this.escapeKeyword(value)})`;
     }

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,12 +175,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         super(printer, resolver, typeConvertor, Language.ARKTS);
         this.arrayConvertor = arrayConvertor;
     }
-    pushNamespace(namespace, options) {
-        if (options.isDefault) {
-            this.print(`export default ${namespace}`);
-        }
-        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;