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

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

@@ -1,43 +1,36 @@
 import { IndentedPrinter } from "../IndentedPrinter";
 import { Language } from "../Language";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
-import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 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 { 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, nameConvertor) {
     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, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new TSTypeNameConvertor(library));
+        case Language.ARKTS: return new ETSLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new ETSTypeNameConvertor(library), new CppConvertor(library));
+        case Language.CPP: return new CppLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new CppConvertor(library), PrimitiveTypesInstance);
+        case Language.CJ: return new CJLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new CJTypeNameConvertor(library), new CJIDLTypeToForeignStringConvertor(library));
+        case Language.KOTLIN: return new KotlinLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new KotlinTypeNameConvertor(library));
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
-export function createInteropArgConvertor(language) {
+export function createInteropArgConvertor(language, library) {
     switch (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 KotlinTypeNameConvertor(library);
     }
     throw new Error(`InteropArgConvertor for language ${language} not implemented`);
 }
-const EmptyReferenceResolver = createEmptyReferenceResolver();
 //# sourceMappingURL=index.js.map

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

@@ -27,4 +27,6 @@ export declare function convertDeclaration<T>(convertor: DeclarationConvertor<T>
 export interface NodeConvertor<T> extends TypeConvertor<T>, DeclarationConvertor<T> {
 }
 export declare function convertNode<T>(convertor: NodeConvertor<T>, node: idl.IDLNode): T;
+export declare function isInsideInstanceof(): boolean;
+export declare function withInsideInstanceof<T>(isInsideInstanceof: boolean, op: () => T): T;
 //# sourceMappingURL=nameConvertor.d.ts.map

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

@@ -62,4 +62,15 @@ export function convertNode(convertor, node) {
         return convertType(convertor, node);
     throw new Error(`Unknown node type ${idl.IDLKind[node.kind]}`);
 }
+let _isInsideInstanceof = false;
+export function isInsideInstanceof() {
+    return _isInsideInstanceof;
+}
+export function withInsideInstanceof(isInsideInstanceof, op) {
+    const prevIsInsideInstanceof = _isInsideInstanceof;
+    _isInsideInstanceof = isInsideInstanceof;
+    const result = op();
+    _isInsideInstanceof = prevIsInsideInstanceof;
+    return result;
+}
 //# sourceMappingURL=nameConvertor.js.map

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
      */
@@ -380,7 +386,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         return createReferenceType('Tag');
     }
     getRuntimeType() {
-        return createReferenceType(`RuntimeType`);
+        return createReferenceType(`idlize.stdlib.RuntimeType`);
     }
     makeTupleAssign(receiver, tupleFields) {
         const statements = tupleFields.map((field, index) => {

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";
@@ -38,14 +38,11 @@ export declare class ETSLambdaExpression extends LambdaExpression {
     protected get statementHasSemicolon(): boolean;
     asString(): string;
 }
-export declare function generateTypeCheckerName(typeName: string): string;
 export declare function generateEnumToNumericName(entry: idl.IDLEntry): string;
 export declare function generateEnumFromNumericName(entry: idl.IDLEntry): string;
-export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
 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;
@@ -75,12 +72,7 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
-    typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
-    makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
-    static _isUseTypeChecker: boolean;
-    static get isUseTypeChecker(): boolean;
-    static useTypeChecker<T>(isUseTypeChecker: boolean, op: () => T): T;
+    instanceOf(value: string, type: idl.IDLType): LanguageExpression;
 }
-export declare function makeEnumTypeCheckerCall(valueAccessor: string, enumName: string, writer: LanguageWriter): LanguageExpression;
 //# sourceMappingURL=ETSLanguageWriter.d.ts.map

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

@@ -18,7 +18,7 @@ import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
 import { getExtAttribute, IDLThisType } from '../../idl';
 import { AggregateConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
-import { convertDeclaration } from "../nameConvertor";
+import { convertDeclaration, withInsideInstanceof } from "../nameConvertor";
 import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
 import { Language } from "../../Language";
 ////////////////////////////////////////////////////////////////
@@ -56,7 +56,7 @@ export class EtsAssignStatement {
             const typeClause = this.type !== undefined ? `: ${writer.getNodeName(this.type)}` : '';
             const maybeAssign = this.expression !== undefined ? " = " : "";
             const initValue = this.expression !== undefined ? this.expression : writer.makeString("");
-            writer.print(`${this.isConst ? "const" : "let"} ${this.variableName} ${typeClause}${maybeAssign}${initValue.asString()}`);
+            writer.print(`${this.isConst ? "const" : "let"} ${this.variableName}${typeClause}${maybeAssign}${initValue.asString()}`);
         }
         else {
             const receiver = (_a = this.options) === null || _a === void 0 ? void 0 : _a.receiver;
@@ -90,35 +90,30 @@ export class ArkTSEnumEntityStatement {
     write(writer) {
         let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
         enumName = enumName.split('.').at(-1);
-        const members = this.enumEntity.elements
-            .flatMap((member, index) => {
+        const correctStyleNames = [];
+        const originalStyleNames = [];
+        this.enumEntity.elements.forEach((member, index) => {
             var _a;
             const initText = (_a = member.initializer) !== null && _a !== void 0 ? _a : index;
             const isTypeString = typeof initText !== "number";
             const originalName = getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
-            const res = [{
-                    name: member.name,
-                    alias: undefined,
-                    stringId: isTypeString ? initText : undefined,
-                    numberId: initText
-                }];
-            if (originalName !== undefined) {
-                res.push({
-                    name: originalName,
-                    alias: undefined,
-                    stringId: isTypeString ? initText : undefined,
-                    numberId: initText
-                });
-                //TODO: enums do not support member aliases
-                // res.push({
-                //     name: originalName,
-                //     alias: member.name,
-                //     stringId: undefined,
-                //     numberId: initText as number
-                // })
-            }
-            return res;
+            correctStyleNames.push({
+                name: originalName ? member.name : `${member.name}_DUMMY`,
+                alias: undefined,
+                stringId: isTypeString ? initText : undefined,
+                numberId: initText
+            });
+            originalStyleNames.push({
+                name: originalName !== null && originalName !== void 0 ? originalName : member.name,
+                alias: undefined,
+                stringId: isTypeString ? initText : undefined,
+                numberId: initText
+            });
         });
+        let members = originalStyleNames;
+        if (this.enumEntity.elements.some(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.OriginalEnumMemberName))) {
+            members = members.concat(correctStyleNames);
+        }
         writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
     }
 }
@@ -149,12 +144,6 @@ export class ETSLambdaExpression extends LambdaExpression {
 ////////////////////////////////////////////////////////////////
 //                           UTILS                            //
 ////////////////////////////////////////////////////////////////
-export function generateTypeCheckerName(typeName) {
-    return "is" + typeName
-        .replaceAll('[]', 'BracketsArray')
-        .replaceAll(/<.*$/g, '') // delete type arguments
-        .replaceAll('.', '_');
-}
 export function generateEnumToNumericName(entry) {
     const typeName = idl.getQualifiedName(entry, "namespace.name").split('.').join('_');
     return `${typeName}_ToNumeric`;
@@ -163,10 +152,6 @@ export function generateEnumFromNumericName(entry) {
     const typeName = idl.getQualifiedName(entry, "namespace.name").split('.').join('_');
     return `${typeName}_FromNumeric`;
 }
-export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
-    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
-    ]);
-}
 ////////////////////////////////////////////////////////////////
 //                           WRITER                           //
 ////////////////////////////////////////////////////////////////
@@ -175,9 +160,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);
@@ -207,18 +189,22 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return this.makeString(`${value} as ${type}`);
     }
     i32FromEnum(value, enumEntry) {
-        if (ETSLanguageWriter.isUseTypeChecker) {
-            return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumEntry), [value]);
+        if (idl.isStringEnum(enumEntry)) {
+            let extractorStatement = this.makeMethodCall(value.asString(), 'getOrdinal', []);
+            if (enumEntry.elements.some(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.OriginalEnumMemberName))) {
+                extractorStatement = this.makeNaryOp('%', [
+                    extractorStatement,
+                    this.makeString(enumEntry.elements.length.toString())
+                ]);
+            }
+            return extractorStatement;
+        }
+        else {
+            return this.makeMethodCall(value.asString(), 'valueOf', []);
         }
-        return idl.isStringEnum(enumEntry)
-            ? this.makeMethodCall(value.asString(), 'getOrdinal', [])
-            : this.makeMethodCall(value.asString(), 'valueOf', []);
     }
     enumFromI32(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        if (ETSLanguageWriter.isUseTypeChecker) {
-            return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumEntry), [value]);
-        }
         return idl.isStringEnum(enumEntry)
             ? this.makeString(`${enumName}.values()[${value.asString()}]`)
             : this.makeMethodCall(enumName, 'fromValue', [value]);
@@ -230,7 +216,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
             || convertor instanceof CustomTypeConvertor) {
             return this.instanceOf(value, convertor.idlType);
         }
-        return this.makeString(`${value} instanceof ${convertor.targetType(this)}`);
+        return this.makeString(`${value} instanceof ${withInsideInstanceof(true, () => convertor.targetType(this))}`);
     }
     makeValueFromOption(value, destinationConvertor) {
         if (idl.isEnum(this.resolver.toDeclaration(destinationConvertor.nativeType()))) {
@@ -269,15 +255,16 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return super.makeNaryOp('==', args);
     }
     discriminate(value, index, type, runtimeTypes) {
-        // work around ArkTS compiler bugs
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            const arrayTypeName = this.arrayConvertor.convert(type);
-            return `TypeChecker.${generateTypeCheckerName(arrayTypeName)}(${value})`;
-        }
-        if (this.getNodeName(type) === "DragPreviewMode") {
-            return `TypeChecker.isDragPreviewMode(${value})`;
-        }
-        return `${value} instanceof ${this.getNodeName(type)}`;
+        return `${value} instanceof ${withInsideInstanceof(true, () => {
+            let typeName = this.getNodeName(type);
+            if (idl.isReferenceType(type)) {
+                const decl = this.resolver.resolveTypeReference(type);
+                if (decl && idl.isInterface(decl) && decl.subkind == idl.IDLInterfaceSubkind.Tuple) {
+                    typeName = "Tuple";
+                }
+            }
+            return typeName;
+        })}`;
     }
     castToInt(value, bitness) {
         // This fix is used to avoid unnecessary writeInt8(value as int32) call, which is generated if value is already an int32
@@ -287,50 +274,23 @@ export class ETSLanguageWriter extends TSLanguageWriter {
             return `(${value}).toChar()`;
         return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
-    castToBoolean(value) { return `${value} ? 1 : 0`; }
-    typeInstanceOf(type, value, members) {
-        if (!members || members.length === 0) {
-            throw new Error("At least one member needs to provided to pass it to TypeChecker!");
-        }
-        const prop = members[0];
-        // Use the same typeInstanceOf<T>(...) method to compile the ETS code by two compilers ArkTS and TS
-        return this.makeString(`TypeChecker.typeInstanceOf<${this.getNodeName(type)}>(value, "${prop}")`);
-    }
-    makeTypeCast(value, type, options) {
-        return this.makeString(`TypeChecker.typeCast<${this.getNodeName(type)}>(value)`);
-    }
+    castToBoolean(value) { return `${value} ? true : false`; }
     makeCast(value, node, options) {
         var _a;
         if (node === idl.IDLI64Type)
-            return this.makeMethodCall(value.asString(), `toLong`, []);
+            return this.makeMethodCall(value.asString() + '!', `toLong`, []);
         if (node === idl.IDLI32Type)
-            return this.makeMethodCall(value.asString(), `toInt`, []);
+            return this.makeMethodCall(value.asString() + '!', `toInt`, []);
         if (node === idl.IDLI8Type)
-            return this.makeMethodCall(value.asString(), `toByte`, []);
+            return this.makeMethodCall(value.asString() + '!', `toByte`, []);
         if (node === idl.IDLF64Type)
-            return this.makeMethodCall(value.asString(), `toDouble`, []);
+            return this.makeMethodCall(value.asString() + '!', `toDouble`, []);
         if (node === idl.IDLF32Type)
-            return this.makeMethodCall(value.asString(), `toFloat`, []);
+            return this.makeMethodCall(value.asString() + '!', `toFloat`, []);
         return new TSCastExpression(value, `${this.getNodeName(node)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
-    static get isUseTypeChecker() { return this._isUseTypeChecker; }
-    static useTypeChecker(isUseTypeChecker, op) {
-        const prevIsUse = this.isReferenceRelativeToNamespaces;
-        this._isUseTypeChecker = isUseTypeChecker;
-        const result = op();
-        this._isUseTypeChecker = prevIsUse;
-        return result;
+    instanceOf(value, type) {
+        return this.makeString(this.discriminate(value, -1, type, []));
     }
 }
-ETSLanguageWriter._isUseTypeChecker = true;
-function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
-    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
-        ...allFields.map(it => {
-            return writer.makeString(duplicates.has(it) ? "true" : "false");
-        })
-    ]);
-}
-export function makeEnumTypeCheckerCall(valueAccessor, enumName, writer) {
-    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(enumName), [writer.makeString(valueAccessor)]);
-}
 //# sourceMappingURL=ETSLanguageWriter.js.map

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;