@idlizer/core 2.1.2 → 2.1.7

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

@@ -25,16 +25,18 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return idl.getFQName(node);
+        return idl.getQualifiedName(node, "namespace.name");
     }
     convertEnum(node) {
-        return idl.getFQName(node);
+        return idl.getQualifiedName(node, "namespace.name");
     }
     convertTypedef(node) {
         return node.name;
     }
     convertCallback(node) {
-        return node.name;
+        return idl.isSyntheticEntry(node)
+            ? this.mapCallback(node)
+            : node.name;
     }
     convertMethod(node) {
         return node.name;
@@ -72,53 +74,65 @@ export class TSTypeNameConvertor {
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
         return type.name;
     }
+    convertTypeReferenceAsImport(type, importClause) {
+        var _a;
+        const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) ? `<${type.typeArguments.join(', ')}>` : "";
+        let decl = this.resolver.resolveTypeReference(type);
+        if (decl)
+            return `${decl.name}${maybeTypeArguments}`;
+        return `${type.name}${maybeTypeArguments}`;
+    }
     convertTypeReference(type) {
         var _a, _b;
         let decl = this.resolver.resolveTypeReference(type);
         if (decl) {
             if (idl.isSyntheticEntry(decl)) {
                 if (idl.isCallback(decl)) {
-                    return this.mapCallback(decl);
+                    return this.mapCallback(decl, type.typeArguments);
                 }
                 const entity = idl.getExtAttribute(decl, idl.IDLExtendedAttributes.Entity);
                 if (entity) {
                     const isTuple = entity === idl.IDLEntity.Tuple;
-                    return this.productType(decl, isTuple, !isTuple);
+                    return this.productType(decl, type.typeArguments, isTuple, !isTuple);
                 }
             }
+            // FIXME: isEnumMember is not TYPE!
+            if (decl && idl.isEnumMember(decl) && decl.parent) {
+                // when `interface A { field?: MyEnum.Value1 }` is generated, it is not possible
+                // to deserialize A, because there is no such type information in declaration target
+                // (can not cast MyEnum to exact MyEnum.Value1)
+                decl = decl.parent;
+            }
+            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`)
+                return `${typeArgs} | undefined`;
+            if (typeSpec === `Function`)
+                return this.mapFunctionType(typeArgs);
+            const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
+            if (decl) {
+                const path = idl.getNamespacesPathFor(decl).map(it => it.name);
+                path.push(decl.name);
+                return `${path.join(".")}${maybeTypeArguments}`;
+            }
+            return `${type.name}${maybeTypeArguments}`;
         }
-        // FIXME: isEnumMember is not TYPE!
-        if (decl && idl.isEnumMember(decl) && decl.parent) {
-            // when `interface A { field?: MyEnum.Value1 }` is generated, it is not possible
-            // to deserialize A, because there is no such type information in declaration target
-            // (can not cast MyEnum to exact MyEnum.Value1)
-            decl = decl.parent;
-        }
-        let typeSpec = type.name;
-        let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it))) !== null && _b !== void 0 ? _b : [];
-        if (typeSpec === `Optional`)
-            return `${typeArgs} | undefined`;
-        if (typeSpec === `Function`)
-            return this.mapFunctionType(typeArgs);
-        const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
-        if (decl) {
-            const path = idl.getNamespacesPathFor(decl).map(it => it.name);
-            path.push(decl.name);
-            return `${path.join(".")}${maybeTypeArguments}`;
-        }
-        return `${type.name}${maybeTypeArguments}`;
+        return this.convert(idl.IDLCustomObjectType);
     }
     convertTypeParameter(type) {
         return type.name;
     }
     convertPrimitiveType(type) {
         switch (type) {
+            case idl.IDLFunctionType: return 'Function';
             case idl.IDLUnknownType:
-            case idl.IDLCustomObjectType: return 'unknown';
+            case idl.IDLCustomObjectType: return 'any';
             case idl.IDLThisType: return 'this';
+            case idl.IDLObjectType: return 'Object';
             case idl.IDLAnyType: return 'any';
             case idl.IDLUndefinedType: return 'undefined';
             case idl.IDLPointerType: return 'KPointer';
@@ -155,13 +169,50 @@ export class TSTypeNameConvertor {
     processTupleType(idlProperty) {
         return idlProperty;
     }
-    mapCallback(decl) {
-        const params = decl.parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}`);
+    createTypeSubstitution(parameters, args) {
+        const subst = new Map();
+        if (args && parameters) {
+            for (let i = 0; i < args.length && i < parameters.length; ++i) {
+                subst.set(parameters[i], args[i]);
+            }
+        }
+        return subst;
+    }
+    applySubstitution(subst, type) {
+        var _a;
+        if (idl.isContainerType(type)) {
+            return idl.createContainerType(type.containerKind, type.elementType.map(it => this.applySubstitution(subst, it)));
+        }
+        if (idl.isReferenceType(type)) {
+            return idl.createReferenceType(type.name, (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.applySubstitution(subst, it)));
+        }
+        if (idl.isTypeParameterType(type)) {
+            const record = subst.get(type.name);
+            if (record) {
+                return record;
+            }
+        }
+        return type;
+    }
+    mapCallback(decl, args) {
+        const subst = this.createTypeSubstitution(decl.typeParameters, args);
+        const parameters = decl.parameters.map(it => {
+            const param = idl.clone(it);
+            param.type = this.applySubstitution(subst, param.type);
+            return param;
+        });
+        const params = parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}${it.isVariadic ? "[]" : ""}`);
         return `((${params.join(", ")}) => ${this.convert(decl.returnType)})`;
     }
-    productType(decl, isTuple, includeFieldNames) {
+    productType(decl, args, isTuple, includeFieldNames) {
+        const subst = this.createTypeSubstitution(decl.typeParameters, args);
         const name = `${isTuple ? "[" : "{"} ${decl.properties
             .map(it => isTuple ? this.processTupleType(it) : it)
+            .map(it => {
+            const prop = idl.clone(it);
+            prop.type = this.applySubstitution(subst, prop.type);
+            return prop;
+        })
             .map(it => {
             const type = this.convert(it.type);
             return it.isOptional
@@ -181,7 +232,7 @@ export class TSInteropArgConvertor {
     convertContainer(type) {
         throw new Error(`Cannot pass container types through interop`);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
         throw new Error(`Cannot pass import types through interop`);
     }
     convertOptional(type) {
@@ -192,14 +243,14 @@ export class TSInteropArgConvertor {
             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 'number';
             case idl.IDLBigintType: return 'bigint';
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
-            case idl.IDLBufferType: return `ArrayBuffer`;
-            case idl.IDLLengthType: return 'Length';
+            case idl.IDLBufferType: return 'ArrayBuffer';
             case idl.IDLDate: return 'number';
             case idl.IDLUndefinedType:
             case idl.IDLVoidType:
@@ -210,6 +261,9 @@ export class TSInteropArgConvertor {
     convertTypeParameter(type) {
         throw new Error("Cannot pass type parameters through interop");
     }
+    convertTypeReferenceAsImport(type, importClause) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
     convertTypeReference(type) {
         throw new Error(`Cannot pass type references through interop`);
     }

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

@@ -6,13 +6,15 @@ export interface TypeConvertor<T> {
     convertOptional(type: idl.IDLOptionalType): T;
     convertUnion(type: idl.IDLUnionType): T;
     convertContainer(type: idl.IDLContainerType): T;
-    convertImport(type: idl.IDLReferenceType, importClause: string): T;
+    convertImport(type: idl.IDLImport): T;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): T;
     convertTypeReference(type: idl.IDLReferenceType): T;
     convertTypeParameter(type: idl.IDLTypeParameterType): T;
     convertPrimitiveType(type: idl.IDLPrimitiveType): T;
 }
 export declare function convertType<T>(convertor: TypeConvertor<T>, type: idl.IDLType): T;
 export interface DeclarationConvertor<T> {
+    convertImport(node: idl.IDLImport): T;
     convertNamespace(node: idl.IDLNamespace): T;
     convertInterface(node: idl.IDLInterface): T;
     convertEnum(node: idl.IDLEnum): T;

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

@@ -20,10 +20,12 @@ export function convertType(convertor, type) {
         return convertor.convertUnion(type);
     if (idl.isContainerType(type))
         return convertor.convertContainer(type);
+    if (idl.isImport(type))
+        return convertor.convertImport(type);
     if (idl.isReferenceType(type)) {
         const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
         return importAttr
-            ? convertor.convertImport(type, importAttr)
+            ? convertor.convertTypeReferenceAsImport(type, importAttr)
             : convertor.convertTypeReference(type);
     }
     if (idl.isTypeParameterType(type))
@@ -33,6 +35,8 @@ export function convertType(convertor, type) {
     throw new Error(`Unknown type ${idl.IDLKind[type.kind]}`);
 }
 export function convertDeclaration(convertor, decl) {
+    if (idl.isImport(decl))
+        return convertor.convertImport(decl);
     if (idl.isNamespace(decl))
         return convertor.convertNamespace(decl);
     if (idl.isInterface(decl))

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

@@ -80,7 +80,10 @@ export declare class CJLanguageWriter extends LanguageWriter {
         name: string;
         stringId: string | undefined;
         numberId: number;
-    }[], op: (writer: LanguageWriter) => void): void;
+    }[], options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }, op: (writer: LanguageWriter) => void): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
     writeFunctionDeclaration(name: string, signature: MethodSignature): void;
     writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
@@ -105,7 +108,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     private writeDeclaration;
     writeNativeFunctionCall(printer: LanguageWriter, name: string, signature: MethodSignature): void;
     writeNativeMethodDeclaration(method: Method): void;
-    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
+    i32FromEnum(value: LanguageExpression, _enumEntry: idl.IDLEnum): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeClassInit(type: idl.IDLType, parameters: LanguageExpression[]): LanguageExpression;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
@@ -125,14 +128,14 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeDefinedCheck(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     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: BaseArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeUnwrapOptional(expression: LambdaExpression): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
     makeNull(value?: string): LanguageExpression;
     getTagType(): idl.IDLType;
@@ -144,17 +147,22 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, convertorIndex?: number): LanguageExpression;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
-    makeEnumEntity(enumEntity: idl.IDLEnum, isExport: boolean): LanguageStatement;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    makeEnumEntity(enumEntity: idl.IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     escapeKeyword(word: string): string;
-    pushNamespace(namespace: string, ident?: boolean): void;
-    popNamespace(ident?: boolean): void;
+    pushNamespace(namespace: string, options: {
+        ident: boolean;
+        isDeclared?: boolean;
+    }): void;
+    popNamespace(options: {
+        ident: boolean;
+    }): void;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
-    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
 }
 //# sourceMappingURL=CJLanguageWriter.d.ts.map

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

@@ -267,8 +267,7 @@ export class CJLanguageWriter extends LanguageWriter {
     }
     getNodeName(type) {
         // rework for proper namespace logic
-        let name = this.typeConvertor.convert(type).split('.');
-        return name[name.length - 1];
+        return this.typeConvertor.convert(type);
     }
     writeClass(name, op, superClass, interfaces, generics) {
         let extendsClause = superClass ? `${superClass}` : undefined;
@@ -283,7 +282,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) {
@@ -320,13 +319,13 @@ export class CJLanguageWriter extends LanguageWriter {
         if (nullable) {
             if (receiver == 'this') {
                 this.printer.print('let thisObj = this');
-                super.writeMethodCall('thisObj', method, params, false);
+                super.writeMethodCall('thisObj', this.escapeKeyword(method), params, false);
                 return;
             }
             this.printer.print(`if (let Some(${receiver}) <- ${receiver}) { ${receiver}.${method}(${params.join(", ")}) }`);
         }
         else {
-            super.writeMethodCall(receiver, method, params, nullable);
+            super.writeMethodCall(receiver, this.escapeKeyword(method), params, nullable);
         }
     }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
@@ -339,7 +338,22 @@ export class CJLanguageWriter extends LanguageWriter {
         this.writeDeclaration(name, signature, modifiers);
     }
     writeConstructorImplementation(className, signature, op, superCall, modifiers) {
-        this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}${className}(${signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`).join(", ")}) {`);
+        var _a;
+        let i = 1;
+        while (signature.isArgOptional(signature.args.length - i)) {
+            let smallerSignature = signature.args.slice(0, -i);
+            this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}init (${smallerSignature.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(it)}`).join(", ")}) {`);
+            this.pushIndent();
+            let smallerArgs = (_a = signature.args) === null || _a === void 0 ? void 0 : _a.slice(0, -i).map((_, i) => signature.argName(i)).join(', ');
+            for (let idx = 0; idx < i; idx++) {
+                smallerArgs = smallerArgs.concat(`${i == signature.args.length && idx == 0 ? '' : ', '}Option.None`);
+            }
+            this.print(`${className}(${smallerArgs})`);
+            this.popIndent();
+            this.printer.print(`}`);
+            i += 1;
+        }
+        this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}${className}(${signature.args.map((it, index) => `${signature.argName(index)}: ${this.getNodeName(idl.maybeOptional(it, signature.isArgOptional(index)))}`).join(", ")}) {`);
         this.pushIndent();
         if (superCall) {
             this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
@@ -416,8 +430,8 @@ export class CJLanguageWriter extends LanguageWriter {
     }
     writeDeclaration(name, signature, modifiers, postfix) {
         let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(it => this.supportedModifiers.includes(it)).map(it => this.mapMethodModifier(it)).join(" ");
-        prefix = prefix ? prefix + " " : "";
-        this.print(`${prefix}${((modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) || (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER))) ? '' : 'func '}${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
+        prefix = prefix ? prefix + " " : "public ";
+        this.print(`${prefix}${((modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) || (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER))) ? '' : `${((modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.STATIC)) || (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.PRIVATE))) ? '' : 'open '}func `}${this.escapeKeyword(name)}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(idl.maybeOptional(it, signature.isArgOptional(index)))}`).join(", ")})${this.getNodeName(signature.returnType) == 'this' ? '' : `: ${this.getNodeName(signature.returnType)}`}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
     }
     writeNativeFunctionCall(printer, name, signature) {
         printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${signature.argName(index)}`).join(", ")}) }`);
@@ -428,8 +442,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 +455,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 +509,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 +539,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 +571,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(`, `)})`);
@@ -573,39 +584,15 @@ export class CJLanguageWriter extends LanguageWriter {
         this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
     }
     escapeKeyword(word) {
-        return CJKeywords.has(word) ? word + "_" : word;
+        return CJKeywords.has(word) ? word.concat("_") : word;
     }
-    pushNamespace(namespace, ident = true) { }
-    popNamespace(ident = true) { }
+    pushNamespace(namespace, options) { }
+    popNamespace(options) { }
     castToInt(value, bitness) {
         return `Int${bitness}(${value})`;
     }
     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