@idlizer/core 2.1.9-arktscgen-5 → 2.1.9-arktscgen-8

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,7 +74,6 @@ 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;
@@ -84,6 +83,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     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                         //
@@ -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,9 +310,6 @@ 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);
     }
@@ -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