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

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

@@ -14,7 +14,7 @@
  */
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, CheckOptionalStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
 import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import * as idl from '../../idl';
 import { RuntimeType } from "../common";
@@ -30,15 +30,7 @@ class JavaLambdaExpression extends LambdaExpression {
     }
     asString() {
         const params = this.signature.args.map((it, i) => `${idl.forceAsNamedNode(it).name} ${this.signature.argName(i)}`);
-        return `(${params.join(", ")}) -> { ${this.bodyAsString()} }`;
-    }
-}
-export class JavaCheckDefinedExpression {
-    constructor(value) {
-        this.value = value;
-    }
-    asString() {
-        return `${this.value} != null`;
+        return `(${params.join(", ")}) ->${this.bodyAsString(true)}`;
     }
 }
 export class JavaCastExpression {
@@ -74,11 +66,11 @@ export class JavaAssignStatement extends AssignStatement {
     }
 }
 class JavaMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         const entryVar = `${this.map}Entry`;
@@ -86,7 +78,7 @@ class JavaMapForEachStatement {
         writer.pushIndent();
         writer.print(`var ${this.key} = ${entryVar}.getKey();`);
         writer.print(`var ${this.value} = ${entryVar}.getValue();`);
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -111,7 +103,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     }
     fork(options) {
         var _a;
-        return new JavaLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor);
+        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);
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isExport = true) {
         let genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(', ')}> ` : ``;
@@ -156,7 +148,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, modifiers, getter, setter) {
+    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let isStatic = modifiers.includes(FieldModifier.STATIC);
         let isMutable = !modifiers.includes(FieldModifier.READONLY);
         let containerName = propName.concat("_container");
@@ -177,6 +169,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
             }
         }
         else {
+            // TBD: use initExpr
             this.writeMethodDeclaration(propName, new MethodSignature(propType, []));
         }
     }
@@ -195,17 +188,14 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeReturn(expr) {
         return new CLikeReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        return new CheckOptionalStatement("null", optional, doStatement);
-    }
     makeDefinedCheck(value) {
-        return new JavaCheckDefinedExpression(value);
+        return this.makeString(`${value} != null`);
     }
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new JavaMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new JavaMapForEachStatement(map, key, value, body);
     }
     makeMapSize(map) {
         return this.makeString(`${map}.size()`);

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

@@ -6,6 +6,11 @@ import { ArgConvertor } from "../ArgConvertors";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class KotlinLambdaReturnStatement implements LanguageStatement {
+    expression?: LanguageExpression | undefined;
+    constructor(expression?: LanguageExpression | undefined);
+    write(writer: LanguageWriter): void;
+}
 export declare class KotlinEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
     private readonly options;
@@ -49,11 +54,6 @@ export declare class KotlinNewObjectExpression implements LanguageExpression {
     constructor(objectName: string, params: LanguageExpression[]);
     asString(): string;
 }
-export declare class KotlinCheckDefinedExpression implements LanguageExpression {
-    private value;
-    constructor(value: string);
-    asString(): string;
-}
 export declare class KotlinLanguageWriter extends LanguageWriter {
     protected typeConvertor: IdlNameConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, language?: Language);
@@ -78,6 +78,8 @@ 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 convertInteropArgument;
+    private convertInteropReturnValue;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
@@ -87,7 +89,7 @@ export declare class KotlinLanguageWriter 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;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
@@ -97,10 +99,10 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeThrowError(message: string): LanguageStatement;
     makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
+    makeLambdaReturn(expr: LanguageExpression): 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;
     writePrintLog(message: string): void;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
@@ -108,8 +110,10 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeUndefined(): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
     makeTupleAlloc(option: string): LanguageStatement;
+    makeTupleAccess(value: string, index: number): LanguageExpression;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
     makeArrayLength(array: string, length?: string): LanguageExpression;
+    makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
     makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     makeMapInit(type: idl.IDLType): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
@@ -136,7 +140,6 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     escapeKeyword(keyword: string): string;
-    makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression | undefined;
     makeStaticBlock(op: (writer: LanguageWriter) => void): void;
     pushNamespace(namespace: string, options: {
         ident: boolean;

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

@@ -15,11 +15,19 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, DelegationType, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature } 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 { TSReturnStatement } from './TsLanguageWriter';
 import { removePoints } from '../convertors/CJConvertors';
+export class KotlinLambdaReturnStatement {
+    constructor(expression) {
+        this.expression = expression;
+    }
+    write(writer) {
+        if (this.expression)
+            writer.print(`${this.expression.asString()}`);
+    }
+}
 export class KotlinEnumEntityStatement {
     constructor(enumEntity, options) {
         this.enumEntity = enumEntity;
@@ -100,16 +108,16 @@ export class KotlinEnumWithGetter {
     }
 }
 class KotlinMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for ((${this.key}, ${this.value}) in ${this.map}) {`);
         writer.pushIndent();
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -122,6 +130,17 @@ export class KotlinThrowErrorStatement {
         writer.print(`throw Error("${this.message}")`);
     }
 }
+class KotlinArrayResizeStatement {
+    constructor(array, arrayType, length, deserializer) {
+        this.array = array;
+        this.arrayType = arrayType;
+        this.length = length;
+        this.deserializer = deserializer;
+    }
+    write(writer) {
+        writer.print(`${this.array} = ${this.arrayType}(${this.length})`);
+    }
+}
 export class KotlinLoopStatement {
     constructor(counter, limit, statement) {
         this.counter = counter;
@@ -171,14 +190,6 @@ export class KotlinNewObjectExpression {
         return `${this.objectName}(${this.params.map(it => it.asString()).join(", ")})`;
     }
 }
-export class KotlinCheckDefinedExpression {
-    constructor(value) {
-        this.value = value;
-    }
-    asString() {
-        return `${this.value} != null`;
-    }
-}
 class KotlinUnwrapOptionalExpression {
     constructor(value) {
         this.value = value;
@@ -210,6 +221,13 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return new KotlinLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
+        // another stub. Bad one.
+        // I hope that I will rewrite LWs soon
+        if (idl.isType(type) && idl.isReferenceType(type)) {
+            if (type.name.startsWith('%TEXT%:')) {
+                return type.name.substring(7);
+            }
+        }
         return this.typeConvertor.convert(type);
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
@@ -226,7 +244,8 @@ export class KotlinLanguageWriter extends LanguageWriter {
         this.printer.print(`}`);
     }
     writeInterface(name, op, superInterfaces, generics, isDeclared) {
-        this.printer.print(`public interface ${name} {`);
+        const inheritance = superInterfaces ? (superInterfaces.length > 0 ? `: ${superInterfaces.join(', ')}` : '') : '';
+        this.printer.print(`public interface ${name}${inheritance} {`);
         this.pushIndent();
         op(this);
         this.popIndent();
@@ -273,7 +292,73 @@ export class KotlinLanguageWriter extends LanguageWriter {
     writeNativeMethodDeclaration(method) {
         let name = method.name;
         let signature = method.signature;
-        this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => { });
+        this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => {
+            const args = signature.args.map((type, index) => this.convertInteropArgument(signature.argName(index), type));
+            const interopCallExpression = this.makeFunctionCall(`kotlin${name}`, args);
+            if (signature.returnType === idl.IDLVoidType) {
+                this.writeExpressionStatement(interopCallExpression);
+                return;
+            }
+            const retval = "retval";
+            this.writeStatement(this.makeAssign(retval, undefined, interopCallExpression));
+            this.writeStatement(this.makeReturn(this.convertInteropReturnValue(retval, signature.returnType)));
+        });
+    }
+    convertInteropArgument(varName, type) {
+        const realInteropType = this.getNodeName(type);
+        let expr;
+        switch (realInteropType) {
+            case "KPointer":
+            case "KSerializerBuffer":
+                expr = `${varName}.toCPointer<CPointed>()!!`;
+                break;
+            case "KInt":
+            case "KLong":
+            case "KFloat":
+            case "KDouble":
+            case "KStringPtr":
+            case "KBoolean":
+            case "Float64":
+            case "Float":
+            case "Double":
+            case "UInt":
+            case "Int":
+                expr = varName;
+                break;
+            default: throw new Error(`Unexpected type ${realInteropType} in interop with Kotlin`);
+        }
+        return this.makeString(expr);
+    }
+    convertInteropReturnValue(varName, type) {
+        const realInteropType = this.getNodeName(type);
+        let expr;
+        switch (realInteropType) {
+            case "KPointer":
+                expr = `${varName}.toLong()`;
+                break;
+            case "KInt":
+            case "KLong":
+            case "Float64":
+            case "Float":
+            case "Double":
+            case "Long":
+            case "Int":
+                expr = varName;
+                break;
+            case "String":
+            case "KStringPtr":
+                expr = `${varName}?.toKString() ?: ""`;
+                break;
+            case "Boolean":
+            case "KBoolean":
+                expr = `${varName} != 0.toByte()`;
+                break;
+            case "KInteropReturnBuffer":
+                expr = `${varName}.useContents { KInteropReturnBuffer(length, data.toLong()) }`;
+                break;
+            default: throw new Error(`Unexpected type ${realInteropType} in interop with Kotlin`);
+        }
+        return this.makeString(expr);
     }
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, true, false, modifiers);
@@ -301,7 +386,7 @@ export class KotlinLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, modifiers, getter, setter) {
+    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let containerName = propName.concat("_container");
         let truePropName = this.escapeKeyword(propName);
         if (getter) {
@@ -309,9 +394,10 @@ export class KotlinLanguageWriter extends LanguageWriter {
                 this.print(`private var ${containerName}: ${this.getNodeName(propType)}`);
             }
         }
-        let isStatic = modifiers.includes(FieldModifier.STATIC);
         let isMutable = !modifiers.includes(FieldModifier.READONLY);
-        this.print(`public ${isMutable ? "var " : "val "}${truePropName}: ${this.getNodeName(propType)}`);
+        let isOverride = modifiers.includes(FieldModifier.OVERRIDE);
+        let initializer = initExpr ? ` = ${initExpr.asString()}` : "";
+        this.print(`${isOverride ? 'override ' : ''}public ${isMutable ? "var " : "val "}${truePropName}: ${this.getNodeName(propType)}${initializer}`);
         if (getter) {
             this.pushIndent();
             this.writeGetterImplementation(getter.method, getter.op);
@@ -363,10 +449,10 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return new KotlinThrowErrorStatement(message);
     }
     makeReturn(expr) {
-        return new TSReturnStatement(expr);
+        return new ReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        throw new Error("Not implemented");
+    makeLambdaReturn(expr) {
+        return new KotlinLambdaReturnStatement(expr);
     }
     makeStatement(expr) {
         return new ExpressionStatement(expr);
@@ -374,11 +460,11 @@ export class KotlinLanguageWriter extends LanguageWriter {
     makeLoop(counter, limit, statement) {
         return new KotlinLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new KotlinMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new KotlinMapForEachStatement(map, key, value, body);
     }
     writePrintLog(message) {
-        throw new Error("Not implemented");
+        this.print(`println(\"${message}\")`);
     }
     makeCast(value, node, options) {
         return this.makeString(`${value.asString()} as ${this.getNodeName(node)}`);
@@ -398,12 +484,18 @@ export class KotlinLanguageWriter extends LanguageWriter {
     makeTupleAlloc(option) {
         throw new Error("Not implemented");
     }
+    makeTupleAccess(value, index) {
+        return this.makeString(`${value}.component${index + 1}()`);
+    }
     makeArrayInit(type, size) {
-        return this.makeString(`Array<${this.getNodeName(type.elementType[0])}>(${size !== null && size !== void 0 ? size : ''})`);
+        return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(${size !== null && size !== void 0 ? size : ''})`);
     }
     makeArrayLength(array, length) {
         return this.makeString(`${array}.size`);
     }
+    makeArrayResize(array, arrayType, length, deserializer) {
+        return new KotlinArrayResizeStatement(array, arrayType, length, deserializer);
+    }
     makeClassInit(type, paramenters) {
         throw new Error("Not implemented");
     }
@@ -411,13 +503,13 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return this.makeString(`${this.getNodeName(type)}()`);
     }
     makeMapInsert(keyAccessor, key, valueAccessor, value) {
-        return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
+        return this.makeStatement(this.makeMethodCall(keyAccessor, "put", [this.makeString(key), this.makeString(value)]));
     }
     makeUnwrapOptional(expression) {
         return new KotlinUnwrapOptionalExpression(expression);
     }
     makeDefinedCheck(value) {
-        return new KotlinCheckDefinedExpression(value);
+        return this.makeString(`${value} != null`);
     }
     makeUnionSelector(value, valueType) {
         return this.makeAssign(valueType, undefined, this.makeMethodCall(value, "getSelector", []), false);
@@ -453,13 +545,13 @@ export class KotlinLanguageWriter extends LanguageWriter {
         return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.OVERRIDE];
     }
     get supportedFieldModifiers() {
-        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY];
+        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.OVERRIDE];
     }
     enumFromI32(value, enumEntry) {
         return this.makeString(`${this.getNodeName(enumEntry)}(${value.asString()})`);
     }
     i32FromEnum(value, enumEntry) {
-        return this.makeString(`${value.asString()}.value`);
+        return this.makeString(`${value.asString()}.value!!`);
     }
     makeEnumEntity(enumEntity, options) {
         return new KotlinEnumWithGetter(enumEntity, options.isExport);
@@ -479,9 +571,6 @@ export class KotlinLanguageWriter extends LanguageWriter {
     escapeKeyword(keyword) {
         return keyword;
     }
-    makeDiscriminatorConvertor(convertor, value, index) {
-        throw new Error("Not implemented");
-    }
     makeStaticBlock(op) {
         this.printer.print('companion object {');
         this.printer.pushIndent();

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

@@ -1,7 +1,7 @@
 import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { DelegationCall, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs, ReturnStatement } from "../LanguageWriter";
+import { DelegationCall, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs, ReturnStatement } from "../LanguageWriter";
 import { ArgConvertor } from "../ArgConvertors";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
@@ -65,7 +65,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     }, setter?: {
         method: Method;
         op: () => void;
-    }): void;
+    }, initExpr?: LanguageExpression): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     private writeDeclaration;
@@ -74,16 +74,16 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeThrowError(message: string): LanguageStatement;
     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;
     writePrintLog(message: string): void;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
+    makeDefinedCheck(value: string): LanguageExpression;
     makeTupleAlloc(option: string): LanguageStatement;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
     makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
@@ -100,7 +100,6 @@ export declare class TSLanguageWriter extends LanguageWriter {
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;
-    makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression | undefined;
-    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
 }
 //# sourceMappingURL=TsLanguageWriter.d.ts.map

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

@@ -16,9 +16,9 @@ import * as idl from '../../idl';
 import { isOptionalType } from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, BlockStatement, CheckOptionalStatement, DelegationType, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
-import { rightmostIndexOf, throwException } from "../../util";
+import { rightmostIndexOf } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
@@ -36,7 +36,7 @@ export class TSLambdaExpression extends LambdaExpression {
             const maybeOptional = idl.isOptionalType(it) ? "?" : "";
             return `${this.signature.argName(i)}${maybeOptional}: ${this.convertor.convert(it)}`;
         });
-        return `(${params.join(", ")}): ${this.convertor.convert(this.signature.returnType)} => { ${this.bodyAsString()} }`;
+        return `(${params.join(", ")}): ${this.convertor.convert(this.signature.returnType)} =>${this.bodyAsString(true)}`;
     }
 }
 export class TSCastExpression {
@@ -93,16 +93,16 @@ class TSLoopStatement {
     }
 }
 class TSMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (const [${this.key}, ${this.value}] of ${this.map}) {`);
         writer.pushIndent();
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -133,7 +133,7 @@ export class TSLanguageWriter extends LanguageWriter {
     }
     fork(options) {
         var _a;
-        return new TSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
+        return new TSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
         // another stub. Bad one.
@@ -243,7 +243,7 @@ export class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, modifiers, getter, setter) {
+    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let isStatic = modifiers.includes(FieldModifier.STATIC);
         let isMutable = !modifiers.includes(FieldModifier.READONLY);
         let containerName = propName.concat("_container");
@@ -264,7 +264,7 @@ export class TSLanguageWriter extends LanguageWriter {
             }
         }
         else {
-            this.writeFieldDeclaration(propName, propType, modifiers, idl.isOptionalType(propType));
+            this.writeFieldDeclaration(propName, propType, modifiers, idl.isOptionalType(propType), initExpr);
         }
     }
     writeTypeDeclaration(decl) {
@@ -310,17 +310,14 @@ export class TSLanguageWriter extends LanguageWriter {
     makeReturn(expr) {
         return new TSReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        return new CheckOptionalStatement("undefined", optional, doStatement);
-    }
     makeStatement(expr) {
         return new ExpressionStatement(expr);
     }
     makeLoop(counter, limit, statement) {
         return new TSLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new TSMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new TSMapForEachStatement(map, key, value, body);
     }
     writePrintLog(message) {
         this.print(`console.log("${message}")`);
@@ -355,6 +352,9 @@ export class TSLanguageWriter extends LanguageWriter {
     makeRuntimeType(rt) {
         return this.makeString(`RuntimeType.${RuntimeType[rt]}`);
     }
+    makeDefinedCheck(value) {
+        return this.makeString(`${value} !== undefined`);
+    }
     makeTupleAlloc(option) {
         return new TsTupleAllocStatement(option);
     }
@@ -411,25 +411,9 @@ export class TSLanguageWriter extends LanguageWriter {
     escapeKeyword(keyword) {
         return TSKeywords.has(keyword) ? keyword + "_" : keyword;
     }
-    makeDiscriminatorConvertor(convertor, value, index) {
-        const convertorNativeType = convertor.nativeType();
-        const decl = this.resolver.resolveTypeReference(idl.isReferenceType(convertorNativeType)
-            ? convertorNativeType
-            : idl.createReferenceType(this.getNodeName(convertorNativeType)));
-        if (decl === undefined || !idl.isEnum(decl)) {
-            throwException(`The type reference ${decl === null || decl === void 0 ? void 0 : decl.name} must be Enum`);
-        }
-        const ordinal = idl.isStringEnum(decl)
-            ? this.i32FromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), decl)
-            : this.makeUnionVariantCast(this.getObjectAccessor(convertor, value), this.getNodeName(idl.IDLI32Type), convertor, index);
-        const { low, high } = idl.extremumOfOrdinals(decl);
-        return this.discriminatorFromExpressions(value, convertor.runtimeTypes[0], [
-            this.makeNaryOp(">=", [ordinal, this.makeString(low.toString())]),
-            this.makeNaryOp("<=", [ordinal, this.makeString(high.toString())])
-        ]);
-    }
-    makeSerializerConstructorSignatures() {
-        return [new NamedMethodSignature(idl.IDLVoidType, [], [])];
+    discriminate(value, index, type, runtimeTypes) {
+        const runtimeTypeList = runtimeTypes.map(ty => "RuntimeType." + RuntimeType[ty]).join(", ");
+        return `[${runtimeTypeList}].includes(runtimeType(${value}))`;
     }
 }
 //# sourceMappingURL=TsLanguageWriter.js.map