@idlizer/core 2.1.2 → 2.1.5

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

@@ -283,7 +283,7 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeEnum(name, members, op) {
+    writeEnum(name, members, options, op) {
         this.printer.print(`public enum ${name}{`);
         this.pushIndent();
         for (const member of members) {
@@ -428,8 +428,8 @@ export class CJLanguageWriter extends LanguageWriter {
         name = name.startsWith('_') ? name.slice(1) : name;
         this.print(`func ${name}(${signture}): ${this.typeForeignConvertor.convert(method.signature.returnType)}`);
     }
-    makeEnumCast(_enumEntry, enumName) {
-        return `${enumName}.value`;
+    i32FromEnum(value, _enumEntry) {
+        return this.makeString(`${value.asString()}.value`);
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
         return new CJAssignStatement(variableName, type, expr, isDeclared, isConst);
@@ -441,7 +441,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(Int64(${size !== null && size !== void 0 ? size : ''}))`);
     }
     makeMapInit(type) {
-        throw new Error(`TBD`);
+        return this.makeString(`${this.getNodeName(type)}()`);
     }
     makeArrayLength(array, length) {
         return this.makeString(`${array}.size`);
@@ -495,9 +495,9 @@ export class CJLanguageWriter extends LanguageWriter {
     writePrintLog(message) {
         this.print(`println("${message}")`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new CJCastExpression(value, this.getNodeName(type), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new CJCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
     typeInstanceOf(type, value, members) {
         if (idl.isInterface(type)) {
@@ -525,7 +525,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString(methodCall.asString() + '.ordinal');
     }
     makeMapInsert(keyAccessor, key, valueAccessor, value) {
-        return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
+        return this.makeStatement(this.makeMethodCall(keyAccessor, "add", [this.makeString(key), this.makeString(value)]));
     }
     makeNull(value) {
         return new StringExpression(`Option.None`);
@@ -557,14 +557,11 @@ export class CJLanguageWriter extends LanguageWriter {
     makeTupleAccess(value, index) {
         return this.makeString(`${value}.value${index}`);
     }
-    enumFromOrdinal(value, enumEntry) {
+    enumFromI32(value, enumEntry) {
         return this.makeString(`${this.getNodeName(enumEntry)}(${value.asString()})`);
     }
-    ordinalFromEnum(value, _) {
-        return this.makeString(`Int32(${value.asString()}.value)`);
-    }
-    makeEnumEntity(enumEntity, isExport) {
-        return new CJEnumWithGetter(enumEntity, isExport);
+    makeEnumEntity(enumEntity, options) {
+        return new CJEnumWithGetter(enumEntity, options.isExport);
     }
     makeEquals(args) {
         return this.makeString(`refEq(${args.map(arg => `${arg.asString()}`).join(`, `)})`);
@@ -583,29 +580,5 @@ export class CJLanguageWriter extends LanguageWriter {
     castToBoolean(value) {
         return `if (${value}) { Int32(1) } else { Int32(0) }`;
     }
-    makeLengthSerializer(serializer, value) {
-        return this.makeBlock([
-            this.makeStatement(this.makeMethodCall(serializer, "writeInt8", [this.makeRuntimeType(RuntimeType.STRING)])),
-            this.makeStatement(this.makeMethodCall(serializer, "writeString", [this.makeString(`${value}.getValue1()`)]))
-        ], false);
-    }
-    makeLengthDeserializer(deserializer) {
-        const valueType = "valueType";
-        return this.makeBlock([
-            this.makeAssign(valueType, undefined, this.makeMethodCall(deserializer, "readInt8", []), true),
-            this.makeMultiBranchCondition([{
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER, ''),
-                    stmt: this.makeReturn(this.makeString(`Ark_Length(${deserializer}.readFloat32())`))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING, ''),
-                    stmt: this.makeReturn(this.makeString(`Ark_Length(${deserializer}.readString())`))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT, ''),
-                    stmt: this.makeReturn(this.makeString(`Ark_Length(Resource(${deserializer}.readString(), "", 0.0, Option.None, Option.None))`))
-                }], this.makeReturn(this.makeUndefined())),
-        ], false);
-    }
 }
 //# sourceMappingURL=CJLanguageWriter.js.map

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

@@ -37,7 +37,10 @@ export declare abstract class CLikeLanguageWriter extends LanguageWriter {
         name: string;
         stringId: string | undefined;
         numberId: number;
-    }[], op: (writer: LanguageWriter) => void): void;
+    }[], options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }, op: (writer: LanguageWriter) => void): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     private writeDeclaration;
     protected stringifyMethodReturnType(type: idl.IDLType, _?: PrintHint): string;

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

@@ -95,7 +95,7 @@ export class CLikeLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, modifiers, ";");
     }
-    writeEnum(name, members, op) {
+    writeEnum(name, members, options, op) {
         throw new Error("WriteEnum for C-family languages is not implemented");
     }
     writeMethodImplementation(method, op) {

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

@@ -11,9 +11,9 @@ import * as idl from "../../idl";
 export declare class CppCastExpression implements LanguageExpression {
     convertor: IdlNameConvertor;
     value: LanguageExpression;
-    type: IDLType;
+    node: IDLNode;
     private options?;
-    constructor(convertor: IdlNameConvertor, value: LanguageExpression, type: IDLType, options?: MakeCastOptions | undefined);
+    constructor(convertor: IdlNameConvertor, value: LanguageExpression, node: IDLNode, options?: MakeCastOptions | undefined);
     asString(): string;
     private mapTypeWithReceiver;
 }
@@ -91,7 +91,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeMapInit(type: IDLType): LanguageExpression;
     makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
     makeMapResize(mapTypeName: string, keyType: IDLType, valueType: IDLType, map: string, size: string, deserializer: string): LanguageStatement;
-    makeCast(expr: LanguageExpression, type: IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(expr: LanguageExpression, node: IDLNode, options?: MakeCastOptions): LanguageExpression;
     makePointerPropertyAccessExpression(expression: string, name: string): CppPointerPropertyAccessExpression;
     writePrintLog(message: string): void;
     makeDefinedCheck(value: string): LanguageExpression;
@@ -107,19 +107,19 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
     get supportedModifiers(): MethodModifier[];
     get supportedFieldModifiers(): FieldModifier[];
-    enumFromOrdinal(value: LanguageExpression, type: IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, _: IDLType): LanguageExpression;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     makeUnsafeCast(param: string): string;
     makeUnsafeCast_(value: LanguageExpression, type: IDLType, typeOptions?: PrintHint): string;
-    makeEnumCast(enumEntry: idl.IDLEnum, value: string): string;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     escapeKeyword(name: string): string;
-    makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
+    makeEnumEntity(enumEntity: IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     private decayTypeName;
     stringifyMethodReturnType(type: IDLType, hint?: PrintHint): string;
     stringifyMethodArgType(type: IDLType, hint?: PrintHint): string;
     stringifyTypeWithReceiver(type: IDLType, receiver?: string): string;
     makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
-    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
 }
 //# sourceMappingURL=CppLanguageWriter.d.ts.map

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

@@ -25,15 +25,15 @@ import * as idl from "../../idl";
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
 export class CppCastExpression {
-    constructor(convertor, value, type, options) {
+    constructor(convertor, value, node, options) {
         this.convertor = convertor;
         this.value = value;
-        this.type = type;
+        this.node = node;
         this.options = options;
     }
     asString() {
         var _a, _b, _c, _d;
-        if (forceAsNamedNode(this.type).name === "Tag") {
+        if (forceAsNamedNode(this.node).name === "Tag") {
             return `${this.value.asString()} == ${PrimitiveTypeList.UndefinedRuntime} ? ${PrimitiveTypeList.UndefinedTag} : ${PrimitiveTypeList.ObjectTag}`;
         }
         let resultName = '';
@@ -41,7 +41,7 @@ export class CppCastExpression {
             resultName = this.options.overrideTypeName;
         }
         else {
-            const pureName = this.mapTypeWithReceiver(this.type, (_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver);
+            const pureName = this.mapTypeWithReceiver((_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver);
             const qualifiedName = ((_c = this.options) === null || _c === void 0 ? void 0 : _c.toRef) ? `${pureName}&` : pureName;
             resultName = qualifiedName;
         }
@@ -49,12 +49,12 @@ export class CppCastExpression {
             ? `reinterpret_cast<${resultName}>(${this.value.asString()})`
             : `static_cast<${resultName}>(${this.value.asString()})`;
     }
-    mapTypeWithReceiver(type, receiver) {
+    mapTypeWithReceiver(receiver) {
         // make deducing type from receiver
         if (receiver !== undefined) {
             return `std::decay<decltype(${receiver})>::type`;
         }
-        return this.convertor.convert(type);
+        return this.convertor.convert(this.node);
     }
 }
 export class CppPointerPropertyAccessExpression {
@@ -314,8 +314,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     makeMapResize(mapTypeName, keyType, valueType, map, size, deserializer) {
         return new CppMapResizeStatement(mapTypeName, keyType, valueType, map, size, deserializer);
     }
-    makeCast(expr, type, options) {
-        return new CppCastExpression(this.typeConvertor, expr, type, options);
+    makeCast(expr, node, options) {
+        return new CppCastExpression(this.typeConvertor, expr, node, options);
     }
     makePointerPropertyAccessExpression(expression, name) {
         return new CppPointerPropertyAccessExpression(expression, name);
@@ -370,11 +370,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     get supportedFieldModifiers() {
         return [];
     }
-    enumFromOrdinal(value, type) {
-        return this.makeString(`static_cast<${this.typeConvertor.convert(type)}>(` + value.asString() + `)`);
-    }
-    ordinalFromEnum(value, _) {
-        return value;
+    enumFromI32(value, enumEntry) {
+        return this.makeString(`static_cast<${this.typeConvertor.convert(enumEntry)}>(` + value.asString() + `)`);
     }
     makeUnsafeCast(param) {
         return param;
@@ -396,13 +393,13 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return `(${typeName}) (${value.asString()})`;
     }
-    makeEnumCast(enumEntry, value) {
-        return `static_cast<${this.typeConvertor.convert(idl.createReferenceType(enumEntry))}>(${value})`;
+    i32FromEnum(value, enumEntry) {
+        return this.makeString(`static_cast<${this.typeConvertor.convert(idl.createReferenceType(enumEntry))}>(${value.asString()})`);
     }
     escapeKeyword(name) {
         return cppKeywords.has(name) ? name + "_" : name;
     }
-    makeEnumEntity(enumEntity, isExport) {
+    makeEnumEntity(enumEntity, options) {
         return new CppEnumEntityStatement(enumEntity);
     }
     decayTypeName(typeName) {
@@ -463,17 +460,11 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
             idl.IDLSerializerBuffer,
             IDLU32Type,
             createReferenceType("CallbackResourceHolder")
-        ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], [undefined, undefined, undefined, PrintHint.AsPointer]);
+        ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], undefined, [undefined, undefined, undefined, PrintHint.AsPointer]);
         const ownedDataCtor = new NamedMethodSignature(IDLVoidType, [
             createReferenceType("CallbackResourceHolder")
-        ], ["resourceHolder"], [`nullptr`], [undefined, PrintHint.AsPointer]);
+        ], ["resourceHolder"], [`nullptr`], undefined, [undefined, PrintHint.AsPointer]);
         return [ownedDataCtor, fromBufferCtor];
     }
-    makeLengthSerializer(serializer, value) {
-        return undefined;
-    }
-    makeLengthDeserializer(deserializer) {
-        return undefined;
-    }
 }
 //# sourceMappingURL=CppLanguageWriter.js.map

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

@@ -17,8 +17,11 @@ export declare class EtsAssignStatement implements LanguageStatement {
 }
 export declare class ArkTSEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
-    private readonly isExport;
-    constructor(enumEntity: IDLEnum, isExport: boolean);
+    private readonly options;
+    constructor(enumEntity: IDLEnum, options: {
+        isExport: boolean;
+        isDeclare: boolean;
+    });
     write(writer: LanguageWriter): void;
 }
 export declare class ETSLambdaExpression extends LambdaExpression {
@@ -28,8 +31,8 @@ export declare class ETSLambdaExpression extends LambdaExpression {
     asString(): string;
 }
 export declare function generateTypeCheckerName(typeName: string): string;
-export declare function generateEnumToOrdinalName(typeName: string): string;
-export declare function generateEnumFromOrdinalName(typeName: string): string;
+export declare function generateEnumToNumericName(typeName: string): string;
+export declare function generateEnumFromNumericName(typeName: string): string;
 export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
@@ -44,14 +47,17 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     get supportedModifiers(): MethodModifier[];
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     makeDiscriminatorFromFields(convertor: {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
-    makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
+    makeEnumEntity(enumEntity: IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     isQuickType(type: IDLType): boolean;
@@ -66,7 +72,7 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     instanceOf(convertor: ArgConvertor, value: string, duplicateMembers?: Set<string>): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
-    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): 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

@@ -63,9 +63,9 @@ class ArkTSMapForEachStatement {
     }
 }
 export class ArkTSEnumEntityStatement {
-    constructor(enumEntity, isExport) {
+    constructor(enumEntity, options) {
         this.enumEntity = enumEntity;
-        this.isExport = isExport;
+        this.options = options;
     }
     write(writer) {
         let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
@@ -99,10 +99,7 @@ export class ArkTSEnumEntityStatement {
             }
             return res;
         });
-        const nss = idl.getNamespacesPathFor(this.enumEntity);
-        nss.forEach(it => writer.pushNamespace(it.name));
-        writer.writeEnum(enumName, members);
-        nss.forEach(() => writer.popNamespace());
+        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
     }
 }
 export class ETSLambdaExpression extends LambdaExpression {
@@ -137,13 +134,13 @@ export function generateTypeCheckerName(typeName) {
         .replaceAll('.', ''); // Todo: hack for namespaces
     return `is${typeName.replaceAll('[]', 'Brackets')}`;
 }
-export function generateEnumToOrdinalName(typeName) {
+export function generateEnumToNumericName(typeName) {
     typeName = typeName.split(".").join("_");
-    return `${typeName}_ToOrdinal`;
+    return `${typeName}_ToNumeric`;
 }
-export function generateEnumFromOrdinalName(typeName) {
+export function generateEnumFromNumericName(typeName) {
     typeName = typeName.split(".").join("_");
-    return `${typeName}_FromOrdinal`;
+    return `${typeName}_FromNumeric`;
 }
 export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
@@ -182,13 +179,13 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`${value} as ${type}`);
     }
-    enumFromOrdinal(value, enumEntry) {
+    i32FromEnum(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumFromOrdinalName(enumName), [this.makeString(value.asString())]);
+        return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumName), [value]);
     }
-    ordinalFromEnum(value, enumEntry) {
+    enumFromI32(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumToOrdinalName(enumName), [this.makeString(value.asString())]);
+        return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumName), [value]);
     }
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         if (convertor instanceof AggregateConvertor
@@ -208,8 +205,11 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeIsTypeCall(value, decl) {
         return makeInterfaceTypeCheckerCall(value, decl.name, decl.properties.map(it => it.name), new Set(), this);
     }
-    makeEnumEntity(enumEntity, isExport) {
-        return new ArkTSEnumEntityStatement(enumEntity, isExport);
+    makeEnumEntity(enumEntity, options) {
+        return new ArkTSEnumEntityStatement(enumEntity, {
+            isExport: options === null || options === void 0 ? void 0 : options.isExport,
+            isDeclare: !!(options === null || options === void 0 ? void 0 : options.isDeclare),
+        });
     }
     getObjectAccessor(convertor, value, args) {
         return super.getObjectAccessor(convertor, value, args);
@@ -304,9 +304,9 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeTypeCast(value, type, options) {
         return this.makeString(`TypeChecker.typeCast<${this.getNodeName(type)}>(value)`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new TSCastExpression(value, `${this.getNodeName(type)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new TSCastExpression(value, `${this.getNodeName(node)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
 }
 function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {

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

@@ -57,7 +57,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
-    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeUnionSelector(value: string, valueType: string): LanguageStatement;
     makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, _type: string, convertorIndex: number): LanguageExpression;
@@ -69,7 +69,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
     getTagType(): idl.IDLType;
     getRuntimeType(): idl.IDLType;
@@ -80,12 +80,10 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     makeMapInit(type: idl.IDLType): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     makeValueFromOption(value: string): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     castToBoolean(value: string): string;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
 }
 //# sourceMappingURL=JavaLanguageWriter.d.ts.map

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

@@ -100,6 +100,13 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         this.typeConvertor = typeConvertor;
     }
     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);
     }
     fork(options) {
@@ -203,9 +210,9 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeMapSize(map) {
         return this.makeString(`${map}.size()`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new JavaCastExpression(value, this.getNodeName(type), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new JavaCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
     makeStatement(expr) {
         return new CLikeExpressionStatement(expr);
@@ -276,29 +283,23 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeTupleAccess(value, index) {
         return this.makeString(`${value}.value${index}`);
     }
-    enumFromOrdinal(value, enumEntry) {
+    enumFromI32(value, enumEntry) {
         const enumName = idl.forceAsNamedNode(enumEntry).name;
         const ordinal = value.asString();
         return this.makeString(`${enumName}.values()[${ordinal}]`);
     }
-    ordinalFromEnum(value, _) {
-        return this.makeString(`${value.asString()}.ordinal()`);
-    }
     makeValueFromOption(value) {
         return this.makeString(`${value}`);
     }
     runtimeType(param, valueType, value) {
         this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
     }
-    makeEnumCast(_enumEntry, enumName) {
-        return `${enumName}.value`;
+    i32FromEnum(value, enumEntry) {
+        const i32Value = idl.isStringEnum(enumEntry)
+            ? `${value.asString()}.ordinal`
+            : `${value.asString()}.value`;
+        return this.makeString(i32Value);
     }
     castToBoolean(value) { return value; }
-    makeLengthSerializer(serializer, value) {
-        return this.makeBlock([
-            this.makeStatement(this.makeMethodCall(serializer, "writeInt8", [this.makeRuntimeType(RuntimeType.STRING)])),
-            this.makeStatement(this.makeMethodCall(serializer, "writeString", [this.makeString(`${value}.value`)]))
-        ], false);
-    }
 }
 //# sourceMappingURL=JavaLanguageWriter.js.map

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

@@ -47,7 +47,10 @@ export declare class TSLanguageWriter extends LanguageWriter {
         alias?: string | undefined;
         stringId: string | undefined;
         numberId: number;
-    }[]): void;
+    }[], options: {
+        isDeclare?: boolean;
+        isExport: boolean;
+    }): void;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeNativeMethodDeclaration(method: Method): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
@@ -73,7 +76,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
     writePrintLog(message: string): void;
-    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    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;
@@ -89,9 +92,8 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeTupleAssign(receiver: string, fields: string[]): LanguageStatement;
     get supportedModifiers(): MethodModifier[];
     get supportedFieldModifiers(): FieldModifier[];
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    makeEnumCast(enumEntry: idl.IDLEnum, param: string): string;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;