@idlizer/core 2.1.9-arktscgen-6 → 2.1.9-arktscgen-9

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

@@ -59,11 +59,6 @@ export declare class FieldAccessExpression {
     constructor(receiver: string, field: string, nullable?: boolean);
     asString(): string;
 }
-export declare class CheckDefinedExpression implements LanguageExpression {
-    private value;
-    constructor(value: string);
-    asString(): string;
-}
 export interface LanguageStatement {
     write(writer: LanguageWriter): void;
 }
@@ -89,8 +84,9 @@ export declare class ExpressionStatement implements LanguageStatement {
 }
 export declare class BlockStatement implements LanguageStatement {
     statements: LanguageStatement[];
-    private inScope;
-    constructor(statements: LanguageStatement[], inScope?: boolean);
+    readonly inScope: boolean;
+    private newLine;
+    constructor(statements: LanguageStatement[], inScope?: boolean, newLine?: boolean);
     write(writer: LanguageWriter): void;
 }
 export declare class IfStatement implements LanguageStatement {
@@ -113,13 +109,6 @@ export declare class MultiBranchIfStatement implements LanguageStatement {
     constructor(statements: BranchStatement[], elseStatement: LanguageStatement | undefined);
     write(writer: LanguageWriter): void;
 }
-export declare class CheckOptionalStatement implements LanguageStatement {
-    undefinedValue: string;
-    optionalExpression: LanguageExpression;
-    doStatement: LanguageStatement;
-    constructor(undefinedValue: string, optionalExpression: LanguageExpression, doStatement: LanguageStatement);
-    write(writer: LanguageWriter): void;
-}
 export declare class TsEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
     private readonly options;
@@ -143,7 +132,7 @@ export declare abstract class LambdaExpression implements LanguageExpression {
     constructor(originalWriter: LanguageWriter, signature: MethodSignature, resolver: ReferenceResolver, body?: LanguageStatement[] | undefined);
     protected abstract get statementHasSemicolon(): boolean;
     abstract asString(): string;
-    bodyAsString(): string;
+    bodyAsString(isScoped?: boolean): string;
 }
 export declare enum ArgumentModifier {
     OPTIONAL = 0
@@ -156,7 +145,8 @@ export declare enum FieldModifier {
     PROTECTED = 4,
     FINAL = 5,
     VOLATILE = 6,
-    INTERNAL = 7
+    INTERNAL = 7,
+    OVERRIDE = 8
 }
 export declare enum MethodModifier {
     PUBLIC = 0,
@@ -274,14 +264,13 @@ export declare abstract class LanguageWriter {
     }, setter?: {
         method: Method;
         op: () => void;
-    }): void;
+    }, initExpr?: LanguageExpression): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     abstract makeThrowError(message: string): LanguageStatement;
     abstract makeReturn(expr?: LanguageExpression): LanguageStatement;
-    abstract makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     abstract makeRuntimeType(rt: RuntimeType): LanguageExpression;
     abstract getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     abstract makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
@@ -295,7 +284,7 @@ export declare abstract class LanguageWriter {
     abstract makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
     abstract makeLoop(counter: string, limit: string): LanguageStatement;
     abstract makeLoop(counter: string, limit: string, statement: LanguageStatement): LanguageStatement;
-    abstract makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    abstract makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     abstract getTagType(): idl.IDLType;
     abstract getRuntimeType(): idl.IDLType;
     abstract makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
@@ -324,6 +313,7 @@ export declare abstract class LanguageWriter {
     makeThis(): LanguageExpression;
     makeNull(value?: string): LanguageExpression;
     makeVoid(): LanguageExpression;
+    makeLambdaReturn(expr?: LanguageExpression): LanguageStatement;
     makeRuntimeTypeCondition(typeVarName: string, equals: boolean, type: RuntimeType, varName?: string): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
@@ -335,7 +325,7 @@ export declare abstract class LanguageWriter {
     makeNativeCall(nativeModule: NativeModuleType, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeBlock(statements: LanguageStatement[], inScope?: boolean): BlockStatement;
     nativeReceiver(nativeModule: NativeModuleType): string;
-    makeDefinedCheck(value: string): LanguageExpression;
+    abstract makeDefinedCheck(value: string, isTag?: boolean): LanguageExpression;
     makeRuntimeTypeDefinedCheck(runtimeType: string): LanguageExpression;
     makeCondition(condition: LanguageExpression, thenStatement: LanguageStatement, elseStatement?: LanguageStatement, insideIfOp?: () => void, insideElseOp?: () => void): LanguageStatement;
     makeMultiBranchCondition(conditions: BranchStatement[], elseStatement?: LanguageStatement): LanguageStatement;
@@ -344,7 +334,6 @@ export declare abstract class LanguageWriter {
     makeArrayAccess(value: string, indexVar: string): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
     makeUnionSelector(value: string, valueType: string): LanguageStatement;
-    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, _convertorIndex?: number, _runtimeTypeIndex?: number): LanguageExpression;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
     makeUnionTypeDefaultInitializer(): LanguageExpression;
     makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
@@ -357,15 +346,11 @@ export declare abstract class LanguageWriter {
     makeNaryOp(op: string, args: LanguageExpression[]): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     writeNativeMethodDeclaration(method: Method): void;
-    writeUnsafeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     pushIndent(): void;
     popIndent(): void;
     print(string: stringOrNone): void;
     getOutput(): string[];
     makeSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): MethodSignature;
-    makeNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
-    makeNativeMethodNamedSignature(returnType: idl.IDLType, parameters: idl.IDLParameter[]): NamedMethodSignature;
-    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
     mapFieldModifier(modifier: FieldModifier): string;
     mapMethodModifier(modifier: MethodModifier): string;
     /**
@@ -374,10 +359,6 @@ export declare abstract class LanguageWriter {
     makeUnsafeCast(param: string): string;
     makeUnsafeCast_(value: LanguageExpression, type: idl.IDLType, typeOptions?: PrintHint): string;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    makeDiscriminatorFromFields(convertor: {
-        targetType: (writer: LanguageWriter) => string;
-    }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
-    makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
     makeEnumEntity(enumEntity: idl.IDLEnum, options: {
         isExport: boolean;
         isDeclare?: boolean;
@@ -385,9 +366,8 @@ export declare abstract class LanguageWriter {
     makeFieldModifiersList(modifiers: FieldModifier[] | undefined, customFieldFilter?: (field: FieldModifier) => boolean): string;
     escapeKeyword(keyword: string): string;
     makeCastCustomObject(customName: string, _isGenericType: boolean): LanguageExpression;
-    makeHasOwnProperty(value: string, _valueTypeName: string, property: string, propertyTypeName?: string): LanguageExpression;
-    discriminatorFromExpressions(value: string, runtimeType: RuntimeType, exprs: LanguageExpression[]): LanguageExpression;
-    makeDiscriminatorConvertor(_convertor: ArgConvertor, _value: string, _index: number): LanguageExpression | undefined;
+    makeHasOwnProperty(value: string, property: string, propertyTypeName?: string): LanguageExpression;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     makeNot(expr: LanguageExpression): LanguageExpression;
     makeSerializedBufferGetter(serializer: string): LanguageExpression;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
@@ -395,9 +375,8 @@ export declare abstract class LanguageWriter {
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
     makeStaticBlock(op: (writer: LanguageWriter) => void): void;
-    instanceOf(convertor: ArgConvertor, value: string, _duplicateMembers?: Set<string>): LanguageExpression;
+    instanceOf(value: string, type: idl.IDLType): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
-    stringifyTypeOrEmpty(type: idl.IDLType | undefined): string;
     /**
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin

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

@@ -13,7 +13,6 @@
  * limitations under the License.
  */
 import * as idl from "../idl";
-import { indentedBy } from "../util";
 import * as fs from "fs";
 import { RuntimeType } from "./common";
 export class TernaryExpression {
@@ -95,14 +94,6 @@ export class FieldAccessExpression {
         return `${this.receiver}${this.nullable ? "?" : ""}.${this.field}`;
     }
 }
-export class CheckDefinedExpression {
-    constructor(value) {
-        this.value = value;
-    }
-    asString() {
-        return `${this.value} != undefined`;
-    }
-}
 export class ProxyStatement {
     constructor(cb) {
         this.cb = cb;
@@ -121,7 +112,7 @@ export class AssignStatement {
         this.options = options;
     }
     write(writer) {
-        var _a, _b;
+        var _a, _b, _c;
         if (this.isDeclared) {
             const typeSpec = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.overrideTypeName)
                 ? `: ${this.options.overrideTypeName}`
@@ -133,7 +124,9 @@ export class AssignStatement {
             writer.print(`${constSpec} ${this.variableName}${typeSpec} ${initValue}`);
         }
         else {
-            writer.print(`${this.variableName} = ${(_b = this.expression) === null || _b === void 0 ? void 0 : _b.asString()}`);
+            const receiver = (_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver;
+            const withReceiver = receiver ? `${receiver}.` : "";
+            writer.print(`${withReceiver}${this.variableName} = ${(_c = this.expression) === null || _c === void 0 ? void 0 : _c.asString()}`);
         }
     }
 }
@@ -149,13 +142,14 @@ export class ExpressionStatement {
     }
 }
 export class BlockStatement {
-    constructor(statements, inScope = true) {
+    constructor(statements, inScope = true, newLine = true) {
         this.statements = statements;
         this.inScope = inScope;
+        this.newLine = newLine;
     }
     write(writer) {
         if (this.inScope) {
-            writer.print("{");
+            this.newLine ? writer.print("{") : writer.printer.appendLastString(" {");
             writer.pushIndent();
         }
         this.statements.forEach(s => s.write(writer));
@@ -181,7 +175,12 @@ export class IfStatement {
             }
         });
         if (this.elseStatement !== undefined) {
-            writer.print("else");
+            if ((this.thenStatement instanceof BlockStatement) && this.thenStatement.inScope) {
+                writer.printer.appendLastString(" else");
+            }
+            else {
+                writer.print("else");
+            }
             this.writeBody(writer, this.elseStatement, () => {
                 if (this.insideElseOp) {
                     this.insideElseOp();
@@ -212,7 +211,7 @@ export class MultiBranchIfStatement {
                 writer.print(`if (${expr.asString()}) {`);
             }
             else {
-                writer.print(`else if (${expr.asString()}) {`);
+                writer.printer.appendLastString(` else if (${expr.asString()}) {`);
             }
             writer.pushIndent();
             stmt.write(writer);
@@ -220,7 +219,7 @@ export class MultiBranchIfStatement {
             writer.print("}");
         });
         if (this.statements.length > 0 && this.elseStatement !== undefined) {
-            writer.print("else {");
+            writer.printer.appendLastString(" else {");
             writer.pushIndent();
             this.elseStatement.write(writer);
             writer.popIndent();
@@ -228,19 +227,6 @@ export class MultiBranchIfStatement {
         }
     }
 }
-export class CheckOptionalStatement {
-    constructor(undefinedValue, optionalExpression, doStatement) {
-        this.undefinedValue = undefinedValue;
-        this.optionalExpression = optionalExpression;
-        this.doStatement = doStatement;
-    }
-    write(writer) {
-        writer.print(`if (${this.optionalExpression.asString()} != ${this.undefinedValue})`);
-        writer.pushIndent();
-        this.doStatement.write(writer);
-        writer.popIndent();
-    }
-}
 // maybe rename or move of fix
 export class TsEnumEntityStatement {
     constructor(enumEntity, options) {
@@ -287,21 +273,17 @@ export class LambdaExpression {
         this.resolver = resolver;
         this.body = body;
     }
-    bodyAsString() {
-        var _a;
+    bodyAsString(isScoped = false) {
         const writer = this.originalWriter.fork();
         if (this.body) {
-            for (const stmt of this.body) {
-                stmt.write(writer);
-            }
+            writer.writeStatement(new BlockStatement(this.body, isScoped, false));
         }
         writer.features.forEach(([feature, module]) => {
             this.originalWriter.addFeature(feature, module);
         });
-        return (this.body ? ((_a = this.body) === null || _a === void 0 ? void 0 : _a.length) > 1 ? '\n' : '' : '').concat(writer.getOutput()
-            .filter(line => line !== "")
-            .map(line => indentedBy(line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`, 1))
-            .join("\n"));
+        return writer.getOutput()
+            .map(line => (line.endsWith('{') || line.endsWith('}') || line.endsWith(';')) ? line : `${line};`)
+            .join("\n");
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -321,6 +303,7 @@ export var FieldModifier;
     FieldModifier[FieldModifier["FINAL"] = 5] = "FINAL";
     FieldModifier[FieldModifier["VOLATILE"] = 6] = "VOLATILE";
     FieldModifier[FieldModifier["INTERNAL"] = 7] = "INTERNAL";
+    FieldModifier[FieldModifier["OVERRIDE"] = 8] = "OVERRIDE";
 })(FieldModifier || (FieldModifier = {}));
 export var MethodModifier;
 (function (MethodModifier) {
@@ -509,9 +492,12 @@ export class LanguageWriter {
     makeVoid() {
         return this.makeUndefined();
     }
+    makeLambdaReturn(expr) {
+        return this.makeReturn(expr);
+    }
     makeRuntimeTypeCondition(typeVarName, equals, type, varName) {
         const op = equals ? "==" : "!=";
-        return this.makeNaryOp(op, [this.makeRuntimeType(type), this.makeString(typeVarName)]);
+        return this.makeNaryOp(op, [this.makeString(typeVarName), this.makeRuntimeType(type)]);
     }
     makeValueFromOption(value, destinationConvertor) {
         return this.makeString(`${value}!`);
@@ -548,9 +534,6 @@ export class LanguageWriter {
     nativeReceiver(nativeModule) {
         return nativeModule.name;
     }
-    makeDefinedCheck(value) {
-        return new CheckDefinedExpression(value);
-    }
     makeRuntimeTypeDefinedCheck(runtimeType) {
         return this.makeRuntimeTypeCondition(runtimeType, false, RuntimeType.UNDEFINED);
     }
@@ -575,9 +558,6 @@ export class LanguageWriter {
     makeUnionSelector(value, valueType) {
         return this.makeAssign(valueType, undefined, this.makeString(`runtimeType(${value})`), false);
     }
-    makeUnionVariantCondition(_convertor, _valueName, valueType, type, _convertorIndex, _runtimeTypeIndex) {
-        return this.makeString(`RuntimeType.${type.toUpperCase()} == ${valueType}`);
-    }
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`unsafeCast<${type}>(${value})`);
     }
@@ -616,9 +596,6 @@ export class LanguageWriter {
     writeNativeMethodDeclaration(method) {
         this.writeMethodDeclaration(method.name, method.signature);
     }
-    writeUnsafeNativeMethodDeclaration(name, signature) {
-        return;
-    }
     pushIndent() {
         this.printer.pushIndent();
     }
@@ -634,18 +611,6 @@ export class LanguageWriter {
     makeSignature(returnType, parameters) {
         return new MethodSignature(returnType, parameters.map(it => it.type));
     }
-    makeNamedSignature(returnType, parameters) {
-        return NamedMethodSignature.make(returnType, parameters.map(it => ({
-            name: it.name,
-            type: it.isOptional ? idl.createOptionalType(it.type) : it.type
-        })));
-    }
-    makeNativeMethodNamedSignature(returnType, parameters) {
-        return this.makeNamedSignature(returnType, parameters);
-    }
-    makeSerializerConstructorSignatures() {
-        return undefined;
-    }
     mapFieldModifier(modifier) {
         return `${FieldModifier[modifier].toLowerCase()}`;
     }
@@ -664,12 +629,6 @@ export class LanguageWriter {
     runtimeType(param, valueType, value) {
         this.writeStatement(this.makeAssign(valueType, idl.IDLI32Type, this.makeFunctionCall("runtimeType", [this.makeString(value)]), false));
     }
-    makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
-        return this.makeString(`(${this.makeNaryOp("||", accessors.map(it => this.makeString(`${value}!.hasOwnProperty("${it}")`))).asString()})`);
-    }
-    makeIsTypeCall(value, decl) {
-        return this.makeString(`is${decl.name}(${value})`);
-    }
     makeEnumEntity(enumEntity, options) {
         return new TsEnumEntityStatement(enumEntity, { isExport: options.isExport, isDeclare: !!options.isDeclare });
     }
@@ -687,21 +646,16 @@ export class LanguageWriter {
     makeCastCustomObject(customName, _isGenericType) {
         return this.makeString(customName);
     }
-    makeHasOwnProperty(value, _valueTypeName, property, propertyTypeName) {
+    makeHasOwnProperty(value, property, propertyTypeName) {
         const expressions = [this.makeString(`${value}.hasOwnProperty("${property}")`)];
         if (propertyTypeName) {
             expressions.push(this.makeString(`isInstanceOf("${propertyTypeName}", ${value}.${property})`));
         }
         return this.makeNaryOp("&&", expressions);
     }
-    discriminatorFromExpressions(value, runtimeType, exprs) {
-        return this.makeNaryOp("&&", [
-            this.makeNaryOp("==", [this.makeRuntimeType(runtimeType), this.makeString(`${value}_type`)]),
-            ...exprs
-        ]);
-    }
-    makeDiscriminatorConvertor(_convertor, _value, _index) {
-        return undefined;
+    discriminate(value, index, type, runtimeTypes) {
+        // return most common form, suitable for languages that don't have sum types
+        return `${value}.getSelector() == ${index}`;
     }
     makeNot(expr) {
         return this.makeString(`!(${expr.asString()})`);
@@ -720,18 +674,13 @@ export class LanguageWriter {
     makeStaticBlock(op) {
         op(this);
     }
-    instanceOf(convertor, value, _duplicateMembers) {
-        return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
+    instanceOf(value, type) {
+        return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
     }
     // The version of instanceOf() which does not use ArgConvertors
     typeInstanceOf(type, value, members) {
         return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
     }
-    stringifyTypeOrEmpty(type) {
-        if (type === undefined)
-            return "";
-        return this.getNodeName(type);
-    }
     /**
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin

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

@@ -58,9 +58,9 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
             case idl.IDLU64Type:
                 return 'int64';
             case idl.IDLF32Type:
-                return 'float32';
+                return 'float';
             case idl.IDLF64Type:
-                return 'float64';
+                return 'double';
             case idl.IDLNumberType:
                 return 'number';
             case idl.IDLStringType: return 'string';

package/build/lib/src/LanguageWriters/convertors/KotlinConvertors.d.ts

@@ -1,6 +1,7 @@
 import * as idl from '../../idl';
 import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
-import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
+import { InteropReturnTypeConvertor } from './InteropConvertors';
 export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
     protected resolver: ReferenceResolver;
     constructor(resolver: ReferenceResolver);
@@ -22,4 +23,19 @@ export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, I
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     private callbackType;
 }
+export declare class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConvertor {
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+}
+export declare class KotlinCInteropArgConvertor implements TypeConvertor<string> {
+    convert(type: idl.IDLType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+}
 //# sourceMappingURL=KotlinConvertors.d.ts.map

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

@@ -13,7 +13,11 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
+import { isMaterialized } from '../../peer-generation/isMaterialized';
 import { convertNode, convertType } from '../nameConvertor';
+import { removePoints } from './CJConvertors';
+import { InteropReturnTypeConvertor } from './InteropConvertors';
 export class KotlinTypeNameConvertor {
     constructor(resolver) {
         this.resolver = resolver;
@@ -25,10 +29,10 @@ export class KotlinTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return node.name;
+        return removePoints(idl.getQualifiedName(node, 'namespace.name'));
     }
     convertEnum(node) {
-        return node.name;
+        return removePoints(idl.getQualifiedName(node, 'namespace.name'));
     }
     convertTypedef(node) {
         return node.name;
@@ -47,15 +51,15 @@ export class KotlinTypeNameConvertor {
         return `${this.convert(type.type)}?`;
     }
     convertUnion(type) {
-        return type.name;
+        return "Union_" + type.types.map(it => generateSyntheticIdlNodeName(it)).join("_");
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
-            return `Array<${convertType(this, type.elementType[0])}>`;
+            return `ArrayList<${convertType(this, type.elementType[0])}>`;
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
             const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
-            return `Map<${stringes[0]}, ${stringes[1]}>`;
+            return `MutableMap<${stringes[0]}, ${stringes[1]}>`;
         }
         if (idl.IDLContainerUtils.isPromise(type)) {
             return `Any`;
@@ -76,7 +80,7 @@ export class KotlinTypeNameConvertor {
             }
         }
         if (decl) {
-            return decl.name;
+            return removePoints(idl.getQualifiedName(decl, 'namespace.name'));
         }
         return this.convert(idl.IDLCustomObjectType);
     }
@@ -125,4 +129,115 @@ export class KotlinTypeNameConvertor {
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
 }
+const KBoolean = "KBoolean";
+const KInt = "KInt";
+const KLong = "KLong";
+const KFloat = "KFloat";
+const KNativePointer = "KNativePointer";
+const KInteropNumber = "KInteropNumber";
+const KStringPtr = "KStringPtr";
+const KInteropReturnBuffer = "KInteropReturnBuffer";
+const KInteropBuffer = "KInteropBuffer";
+const KSerializerBuffer = "KSerializerBuffer";
+export class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConvertor {
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI8Type:
+            case idl.IDLU8Type:
+            case idl.IDLI16Type:
+            case idl.IDLU16Type:
+            case idl.IDLI32Type:
+            case idl.IDLU32Type:
+            case idl.IDLI64Type:
+            case idl.IDLU64Type:
+            case idl.IDLF16Type:
+            case idl.IDLF32Type:
+            case idl.IDLF64Type: return KInt;
+            case idl.IDLNumberType: return KInteropNumber;
+            case idl.IDLBooleanType: return KBoolean;
+            case idl.IDLBigintType: return KLong;
+            case idl.IDLAnyType:
+            case idl.IDLThisType:
+            case idl.IDLUndefinedType:
+            case idl.IDLUnknownType:
+            case idl.IDLObjectType:
+            case idl.IDLVoidType: return idl.IDLVoidType.name;
+            case idl.IDLBufferType: return KInteropReturnBuffer;
+            case idl.IDLStringType: return KStringPtr;
+            case idl.IDLPointerType: return KNativePointer;
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeReference(type) {
+        if (this.resolver != undefined && idl.isCallback(this.resolver.toDeclaration(type))) {
+            return KNativePointer;
+        }
+        if (type.name.endsWith("Attribute"))
+            return idl.IDLVoidType.name;
+        const decl = this.resolver.resolveTypeReference(type);
+        if (decl) {
+            // Callbacks and array types return by value
+            if (idl.isCallback(this.resolver.toDeclaration(type))) {
+                return type.name;
+            }
+            if (idl.isInterface(decl)) {
+                if (isMaterialized(decl, this.resolver)) {
+                    return KNativePointer;
+                }
+                return KInteropReturnBuffer;
+            }
+            if (idl.isEnum(decl)) {
+                return KInt;
+            }
+        }
+        return idl.IDLVoidType.name;
+    }
+}
+export class KotlinCInteropArgConvertor {
+    convert(type) {
+        return convertType(this, type);
+    }
+    convertContainer(type) {
+        throw new Error(`Cannot pass container types through interop`);
+    }
+    convertImport(type) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertTypeReferenceAsImport(type, importClause) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertOptional(type) {
+        return KNativePointer;
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI64Type: return KLong;
+            case idl.IDLU64Type: return KLong;
+            case idl.IDLI32Type: return KInt;
+            case idl.IDLU32Type: return KInt;
+            case idl.IDLF32Type: return KFloat;
+            case idl.IDLNumberType: return KInteropNumber;
+            case idl.IDLBigintType: return KLong;
+            case idl.IDLSerializerBuffer: return KSerializerBuffer;
+            case idl.IDLBooleanType:
+            case idl.IDLFunctionType: return KInt;
+            case idl.IDLStringType: return KStringPtr;
+            case idl.IDLBufferType: return KInteropBuffer;
+            case idl.IDLDate: return KLong;
+            case idl.IDLUndefinedType:
+            case idl.IDLVoidType:
+            case idl.IDLPointerType: return KNativePointer;
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeParameter(type) {
+        throw new Error("Cannot pass type parameters through interop");
+    }
+    convertTypeReference(type) {
+        throw new Error(`Cannot pass type references through interop`);
+    }
+    convertUnion(type) {
+        throw new Error("Cannot pass union types through interop");
+    }
+}
 //# sourceMappingURL=KotlinConvertors.js.map

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

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { maybeRestoreGenerics } from '../../transformers/GenericTransformer';
 import { convertNode, convertType } from '../nameConvertor';
 export class TSTypeNameConvertor {
     constructor(resolver) {
@@ -107,6 +108,11 @@ export class TSTypeNameConvertor {
                 // (can not cast MyEnum to exact MyEnum.Value1)
                 decl = decl.parent;
             }
+            let maybeRestoredGeneric = maybeRestoreGenerics(type, this.resolver);
+            if (maybeRestoredGeneric) {
+                type = maybeRestoredGeneric;
+                decl = this.resolver.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 : [];
             if (typeSpec === `Optional`)

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

@@ -101,7 +101,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     }, setter?: {
         method: Method;
         op: () => void;
-    }): void;
+    }, initExpr?: LanguageExpression): void;
     writeGetterImplementation(method: Method, op?: (writer: this) => void): void;
     writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
@@ -121,10 +121,9 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeThrowError(message: string): LanguageStatement;
     makeTernary(condition: LanguageExpression, trueExpression: LanguageExpression, falseExpression: LanguageExpression): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     makeDefinedCheck(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     writePrintLog(message: string): void;