@idlizer/core 2.1.7 → 2.1.9-arktscgen-4

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

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { CJKeywords } from '../../languageSpecificKeywords';
 import { convertNode, convertType } from '../nameConvertor';
 import { InteropArgConvertor } from './InteropConvertors';
 export class CJTypeNameConvertor {
@@ -40,6 +41,12 @@ export class CJTypeNameConvertor {
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
             const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
+            if (idl.isReferenceType(type.elementType[0])) {
+                const keyValueType = this.resolver.resolveTypeReference(type.elementType[0]);
+                if (idl.isInterface(keyValueType) || idl.isEnum(keyValueType)) {
+                    return `HashMap<Int64, ${stringes[1]}>`;
+                }
+            }
             return `HashMap<${stringes[0]}, ${stringes[1]}>`;
         }
         if (idl.IDLContainerUtils.isPromise(type)) {
@@ -60,7 +67,7 @@ export class CJTypeNameConvertor {
         return node.name;
     }
     convertCallback(type) {
-        const params = type.parameters.map(it => `${it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
+        const params = type.parameters.map(it => `${CJKeywords.has(it.name) ? it.name.concat("_") : it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
         return `(${params.join(", ")}) -> ${this.convert(type.returnType)}`;
     }
     convertMethod(node) {
@@ -74,15 +81,17 @@ export class CJTypeNameConvertor {
         return type.name;
     }
     convertTypeReferenceAsImport(type, importClause) {
-        return type.name;
+        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 this.convert(idl.IDLCustomObjectType);
     }
     convertTypeReference(type) {
-        if (type.name === "Object")
+        var _a, _b;
+        if (type.name === idl.IDLObjectType.name)
             return "KPointer";
-        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
-        if (importAttr) {
-            return this.convertTypeReferenceAsImport(type, importAttr);
-        }
         // resolve synthetic types
         const decl = this.resolver.resolveTypeReference(type);
         if (decl && idl.isSyntheticEntry(decl)) {
@@ -96,10 +105,12 @@ export class CJTypeNameConvertor {
             }
         }
         let name = type.name.split('.');
+        let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : [];
+        const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
         if (decl) {
-            return idl.getNamespacesPathFor(decl).map(ns => ns.name).join().concat(name[name.length - 1]);
+            return idl.getNamespacesPathFor(decl).map(ns => ns.name).join().concat(name[name.length - 1].concat(maybeTypeArguments));
         }
-        return name[name.length - 1];
+        return this.convert(idl.IDLCustomObjectType);
     }
     convertTypeParameter(type) {
         return type.name;
@@ -129,6 +140,7 @@ export class CJTypeNameConvertor {
             case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLAnyType: return 'Any';
             case idl.IDLDate: return 'DateTime';
+            case idl.IDLObjectType: return 'Any';
             case idl.IDLUnknownType:
             case idl.IDLFunctionType:
             case idl.IDLCustomObjectType: return 'Any';
@@ -136,7 +148,7 @@ export class CJTypeNameConvertor {
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
     callbackType(decl) {
-        const params = decl.parameters.map(it => `${it.name}: ${this.convert(it.type)}`);
+        const params = decl.parameters.map(it => `${CJKeywords.has(it.name) ? it.name.concat("_") : it.name}: ${this.convert(it.type)}`);
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
@@ -150,6 +162,7 @@ export class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
                 case idl.IDLStringType: return 'CString';
                 case idl.IDLInteropReturnBufferType: return 'KInteropReturnBuffer';
                 case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
+                case idl.IDLObjectType: return 'Unit';
             }
         }
         if (idl.isContainerType(type)) {

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

@@ -0,0 +1,24 @@
+import * as idl from '../../idl';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    convert(node: idl.IDLNode): string;
+    convertNamespace(node: idl.IDLNamespace): string;
+    convertInterface(node: idl.IDLInterface): string;
+    convertEnum(node: idl.IDLEnum): string;
+    convertTypedef(node: idl.IDLTypedef): string;
+    convertCallback(node: idl.IDLCallback): string;
+    convertMethod(node: idl.IDLMethod): string;
+    convertConstant(node: idl.IDLConstant): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+}
+//# sourceMappingURL=KotlinConvertor.d.ts.map

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { convertNode } from '../nameConvertor';
+export class KotlinTypeNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    convert(node) {
+        return convertNode(this, node);
+    }
+    convertNamespace(node) {
+        throw new Error("Not implemented");
+    }
+    convertInterface(node) {
+        throw new Error("Not implemented");
+    }
+    convertEnum(node) {
+        throw new Error("Not implemented");
+    }
+    convertTypedef(node) {
+        throw new Error("Not implemented");
+    }
+    convertCallback(node) {
+        throw new Error("Not implemented");
+    }
+    convertMethod(node) {
+        throw new Error("Not implemented");
+    }
+    convertConstant(node) {
+        throw new Error("Not implemented");
+    }
+    convertOptional(type) {
+        throw new Error("Not implemented");
+    }
+    convertUnion(type) {
+        throw new Error("Not implemented");
+    }
+    convertContainer(type) {
+        throw new Error("Not implemented");
+    }
+    convertImport(type) {
+        throw new Error("Not implemented");
+    }
+    convertTypeReferenceAsImport(type, importClause) {
+        throw new Error("Not implemented");
+    }
+    convertTypeReference(type) {
+        throw new Error("Not implemented");
+    }
+    convertTypeParameter(type) {
+        throw new Error("Not implemented");
+    }
+    convertPrimitiveType(type) {
+        throw new Error("Not implemented");
+    }
+}
+//# sourceMappingURL=KotlinConvertor.js.map

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

@@ -0,0 +1,25 @@
+import * as idl from '../../idl';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    convert(node: idl.IDLNode): string;
+    convertNamespace(node: idl.IDLNamespace): string;
+    convertInterface(node: idl.IDLInterface): string;
+    convertEnum(node: idl.IDLEnum): string;
+    convertTypedef(node: idl.IDLTypedef): string;
+    convertCallback(node: idl.IDLCallback): string;
+    convertMethod(node: idl.IDLMethod): string;
+    convertConstant(node: idl.IDLConstant): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    private callbackType;
+}
+//# sourceMappingURL=KotlinConvertors.d.ts.map

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

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as idl from '../../idl';
+import { convertNode, convertType } from '../nameConvertor';
+export class KotlinTypeNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    convert(node) {
+        return convertNode(this, node);
+    }
+    convertNamespace(node) {
+        return node.name;
+    }
+    convertInterface(node) {
+        return node.name;
+    }
+    convertEnum(node) {
+        return node.name;
+    }
+    convertTypedef(node) {
+        return node.name;
+    }
+    convertCallback(node) {
+        const params = node.parameters.map(it => `${it.name}: ${this.convert(it.type)}${it.isOptional ? "?" : ""}`);
+        return `(${params.join(", ")}) -> ${this.convert(node.returnType)}`;
+    }
+    convertMethod(node) {
+        return node.name;
+    }
+    convertConstant(node) {
+        return node.name;
+    }
+    convertOptional(type) {
+        return `${this.convert(type.type)}?`;
+    }
+    convertUnion(type) {
+        return type.name;
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            return `Array<${convertType(this, type.elementType[0])}>`;
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
+            return `Map<${stringes[0]}, ${stringes[1]}>`;
+        }
+        if (idl.IDLContainerUtils.isPromise(type)) {
+            return `Any`;
+        }
+        throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
+    }
+    convertImport(type) {
+        throw new Error("Not implemented");
+    }
+    convertTypeReferenceAsImport(type, importClause) {
+        throw new Error("Not implemented");
+    }
+    convertTypeReference(type) {
+        const decl = this.resolver.resolveTypeReference(type);
+        if (decl && idl.isSyntheticEntry(decl)) {
+            if (idl.isCallback(decl)) {
+                return this.callbackType(decl);
+            }
+        }
+        if (decl) {
+            return decl.name;
+        }
+        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 'Any';
+            case idl.IDLThisType: return 'this';
+            case idl.IDLObjectType: return 'Object';
+            case idl.IDLAnyType: return 'Any';
+            case idl.IDLUndefinedType: return 'Nothing?';
+            case idl.IDLPointerType: return 'KPointer';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
+            case idl.IDLVoidType: return 'Unit';
+            case idl.IDLBooleanType: return 'Boolean';
+            case idl.IDLI8Type: return 'Byte';
+            case idl.IDLU8Type: return 'UByte';
+            case idl.IDLI16Type: return 'Short';
+            case idl.IDLU16Type: return 'UShort';
+            case idl.IDLI32Type: return 'Int';
+            case idl.IDLU32Type: return 'UInt';
+            case idl.IDLI64Type: return 'Long';
+            case idl.IDLU64Type: return 'ULong';
+            case idl.IDLF32Type: return 'Float';
+            case idl.IDLF64Type: return 'Double';
+            case idl.IDLNumberType: return 'Double';
+            case idl.IDLBigintType:
+                return 'BigInteger'; // relies on import java.math.BigInteger
+            case idl.IDLStringType:
+                return 'String';
+            case idl.IDLDate:
+                return 'Date';
+            case idl.IDLBufferType:
+                return 'NativeBuffer';
+            case idl.IDLInteropReturnBufferType:
+                return `KInteropReturnBuffer`;
+        }
+        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    callbackType(decl) {
+        const params = decl.parameters.map(it => `${it.name}: ${this.convert(it.type)}`);
+        return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
+    }
+}
+//# sourceMappingURL=KotlinConvertors.js.map

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

@@ -6,11 +6,13 @@ import { CJIDLTypeToForeignStringConvertor, CJInteropArgConvertor, CJTypeNameCon
 import { CppInteropArgConvertor, CppConvertor } from "./convertors/CppConvertors";
 import { ETSInteropArgConvertor, ETSTypeNameConvertor } from "./convertors/ETSConvertors";
 import { JavaInteropArgConvertor, JavaTypeNameConvertor } from "./convertors/JavaConvertors";
+import { KotlinTypeNameConvertor } from "./convertors/KotlinConvertors";
 import { TSInteropArgConvertor, TSTypeNameConvertor } from "./convertors/TSConvertors";
 import { CJLanguageWriter } from "./writers/CJLanguageWriter";
 import { CppLanguageWriter } from "./writers/CppLanguageWriter";
 import { ETSLanguageWriter } from "./writers/ETSLanguageWriter";
 import { JavaLanguageWriter } from "./writers/JavaLanguageWriter";
+import { KotlinLanguageWriter } from "./writers/KotlinLanguageWriter";
 import { TSLanguageWriter } from "./writers/TsLanguageWriter";
 export * from "./nameConvertor";
 export function createLanguageWriter(language, resolver) {
@@ -22,6 +24,7 @@ export function createLanguageWriter(language, resolver) {
         case Language.JAVA: return new JavaLanguageWriter(printer, resolver, new JavaTypeNameConvertor(resolver));
         case Language.CPP: return new CppLanguageWriter(printer, resolver, new CppConvertor(resolver), PrimitiveTypesInstance);
         case Language.CJ: return new CJLanguageWriter(printer, resolver, new CJTypeNameConvertor(resolver), new CJIDLTypeToForeignStringConvertor(resolver));
+        case Language.KOTLIN: return new KotlinLanguageWriter(printer, resolver, new KotlinTypeNameConvertor(resolver));
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
@@ -32,6 +35,7 @@ export function createInteropArgConvertor(language) {
         case Language.CPP: return CppInteropArgConvertor.INSTANCE;
         case Language.JAVA: return new JavaInteropArgConvertor();
         case Language.CJ: return new CJInteropArgConvertor();
+        case Language.KOTLIN: return new CJInteropArgConvertor();
     }
     throw new Error(`InteropArgConvertor for language ${language} not implemented`);
 }

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

@@ -2,7 +2,7 @@ import * as idl from "../../idl";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { RuntimeType } from "../common";
-import { AssignStatement, FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { AssignStatement, DelegationCall, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
 import { IdlNameConvertor } from "../nameConvertor";
 import { Language } from "../../Language";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
@@ -26,11 +26,11 @@ export declare class CJUnionCastExpression implements LanguageExpression {
     asString(): string;
 }
 export declare class CJMatchExpression implements LanguageExpression {
-    matchValue: LanguageExpression;
+    matchValue: string;
     matchCases: LanguageExpression[];
     caseBlocks: LanguageExpression[];
     indentDepth?: number | undefined;
-    constructor(matchValue: LanguageExpression, matchCases: LanguageExpression[], caseBlocks: LanguageExpression[], indentDepth?: number | undefined);
+    constructor(matchValue: string, matchCases: LanguageExpression[], caseBlocks: LanguageExpression[], indentDepth?: number | undefined);
     asString(): string;
 }
 export declare class CJTernaryExpression implements LanguageExpression {
@@ -91,7 +91,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
-    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
@@ -132,7 +132,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     getObjectAccessor(convertor: BaseArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
-    makeUnwrapOptional(expression: LambdaExpression): LanguageExpression;
+    makeUnwrapOptional(expression: LanguageExpression): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
     protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;

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

@@ -31,7 +31,7 @@ class CJLambdaExpression extends LambdaExpression {
         return false;
     }
     asString() {
-        const params = this.signature.args.map((it, i) => `${this.signature.argName(i)}: ${this.writer.getNodeName(it)}`);
+        const params = this.signature.args.map((it, i) => `${this.writer.escapeKeyword(this.signature.argName(i))}: ${this.writer.getNodeName(it)}`);
         return `{${params.join(", ")} => ${this.bodyAsString()} }`;
     }
 }
@@ -73,11 +73,11 @@ export class CJMatchExpression {
     asString() {
         var _a, _b, _c;
         let output = [];
-        output.push(`match (${this.matchValue.asString()}) {`);
+        output.push(`match (${this.matchValue}) {`);
         for (let index in this.matchCases) {
             output.push(indentedBy(`case ${this.matchCases[index].asString()} => ${this.caseBlocks[index].asString()}`, ((_a = this.indentDepth) !== null && _a !== void 0 ? _a : 0) + 1));
         }
-        output.push(indentedBy(`case _ => throw Exception(\"Unmatched pattern ${this.matchValue.asString()}\")`, ((_b = this.indentDepth) !== null && _b !== void 0 ? _b : 1) + 1));
+        output.push(indentedBy(`case _ => throw Exception(\"Unmatched pattern ${this.matchValue}\")`, ((_b = this.indentDepth) !== null && _b !== void 0 ? _b : 1) + 1));
         output.push(indentedBy(`}`, ((_c = this.indentDepth) !== null && _c !== void 0 ? _c : 1)));
         return output.join('\n');
     }
@@ -184,7 +184,7 @@ export class CJEnumWithGetter {
             }
             memberValue += 1;
         }
-        let enumName = this.enumEntity.name;
+        let enumName = idl.getNamespaceName(this.enumEntity).concat(this.enumEntity.name);
         writer.writeClass(enumName, () => {
             const enumType = idl.createReferenceType(this.enumEntity);
             members.forEach(it => {
@@ -322,7 +322,7 @@ export class CJLanguageWriter extends LanguageWriter {
                 super.writeMethodCall('thisObj', this.escapeKeyword(method), params, false);
                 return;
             }
-            this.printer.print(`if (let Some(${receiver}) <- ${receiver}) { ${receiver}.${method}(${params.join(", ")}) }`);
+            this.printer.print(`if (let Some(${receiver}) <- ${receiver}) { ${receiver}.${this.escapeKeyword(method)}(${params.join(", ")}) }`);
         }
         else {
             super.writeMethodCall(receiver, this.escapeKeyword(method), params, nullable);
@@ -337,26 +337,27 @@ export class CJLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, modifiers);
     }
-    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+    writeConstructorImplementation(className, signature, op, delegationCall, modifiers) {
         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.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}init (${smallerSignature.map((it, index) => `${this.escapeKeyword(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(', ');
+            let lessArgs = (_a = signature.args) === null || _a === void 0 ? void 0 : _a.slice(0, -i).map((_, i) => this.escapeKeyword(signature.argName(i))).join(', ');
             for (let idx = 0; idx < i; idx++) {
-                smallerArgs = smallerArgs.concat(`${i == signature.args.length && idx == 0 ? '' : ', '}Option.None`);
+                lessArgs = lessArgs.concat(`${i == signature.args.length && idx == 0 ? '' : ', '}Option.None`);
             }
-            this.print(`${className}(${smallerArgs})`);
+            this.print(`${className}(${lessArgs})`);
             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.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}${className}(${signature.args.map((it, index) => `${this.escapeKeyword(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(", ")})`);
+        if (delegationCall) {
+            // TBD: check delegationType to write "this" or "super"
+            this.print(`super(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")})`);
         }
         op(this);
         this.popIndent();
@@ -415,7 +416,7 @@ export class CJLanguageWriter extends LanguageWriter {
         this.print('}');
     }
     writeSetterImplementation(method, op) {
-        this.print(`set(${method.signature.argsNames.join(', ')}) {`);
+        this.print(`set(${method.signature.argsNames.map(arg => this.escapeKeyword(arg)).join(', ')}) {`);
         this.pushIndent();
         op(this);
         this.popIndent();
@@ -428,13 +429,14 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.print('}');
     }
-    writeDeclaration(name, signature, modifiers, postfix) {
+    writeDeclaration(name, signature, modifiers, postfix, generics) {
         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 + " " : "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 : ""}`);
+        const typeParams = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : "";
+        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)}${typeParams}(${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(", ")}) }`);
+        printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}`).join(", ")}) }`);
     }
     writeNativeMethodDeclaration(method) {
         let name = method.name;
@@ -446,7 +448,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString(`${value.asString()}.value`);
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
-        return new CJAssignStatement(variableName, type, expr, isDeclared, isConst);
+        return new CJAssignStatement(this.escapeKeyword(variableName), type, expr, isDeclared, isConst);
     }
     makeClassInit(type, parameters) {
         throw new Error(`makeClassInit`);
@@ -501,13 +503,13 @@ export class CJLanguageWriter extends LanguageWriter {
         return new CJMapForEachStatement(map, key, value, op);
     }
     makeDefinedCheck(value) {
-        return new CJCheckDefinedExpression(value);
+        return new CJCheckDefinedExpression(this.escapeKeyword(value));
     }
     makeNewObject(objectName, params = []) {
         return new CJNewObjectExpression(objectName, params);
     }
     writePrintLog(message) {
-        this.print(`println("${message}")`);
+        this.print(`println(\"${message}\")`);
     }
     makeCast(value, node, options) {
         var _a;
@@ -526,10 +528,10 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString("Option.None");
     }
     makeUnwrapOptional(expression) {
-        return new CJMatchExpression(expression, [this.makeString(`Some(unwrap_value)`)], [this.makeString(`unwrap_value`)], this.indentDepth());
+        return new CJMatchExpression(this.escapeKeyword(expression.asString()), [this.makeString(`Some(unwrap_value)`)], [this.makeString(`unwrap_value`)], this.indentDepth());
     }
     makeValueFromOption(value, destinationConvertor) {
-        return this.makeString(`${value}`);
+        return this.makeString(this.escapeKeyword(value));
     }
     makeRuntimeType(rt) {
         return this.makeString(`RuntimeType.${RuntimeType[rt]}.ordinal`);
@@ -589,7 +591,7 @@ export class CJLanguageWriter extends LanguageWriter {
     pushNamespace(namespace, options) { }
     popNamespace(options) { }
     castToInt(value, bitness) {
-        return `Int${bitness}(${value})`;
+        return `Int${bitness}(${this.escapeKeyword(value)})`;
     }
     castToBoolean(value) {
         return `if (${value}) { Int32(1) } else { Int32(0) }`;

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

@@ -42,7 +42,7 @@ export declare abstract class CLikeLanguageWriter extends LanguageWriter {
         isDeclare?: boolean;
     }, op: (writer: LanguageWriter) => void): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
-    private writeDeclaration;
+    protected writeDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[], postfix?: string): void;
     protected stringifyMethodReturnType(type: idl.IDLType, _?: PrintHint): string;
     protected stringifyMethodArgType(type: idl.IDLType, _?: PrintHint): string;
 }

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

@@ -1,7 +1,7 @@
 import { IDLContainerType, IDLEnum, IDLNode, IDLType, IDLTypedef } from '../../idl';
 import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
-import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, MakeRefOptions, Method, PrintHint, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs } from "../LanguageWriter";
+import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, MakeRefOptions, Method, PrintHint, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs, DelegationCall, MethodStaticCallExpression } from "../LanguageWriter";
 import { CLikeLanguageWriter } from "./CLikeLanguageWriter";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
@@ -23,6 +23,9 @@ export declare class CppPointerPropertyAccessExpression implements LanguageExpre
     constructor(expression: string, name: string);
     asString(): string;
 }
+export declare class CPPMethodStaticCallExpression extends MethodStaticCallExpression {
+    asString(): string;
+}
 export declare class CppAssignStatement extends AssignStatement {
     variableName: string;
     type: IDLType | undefined;
@@ -36,16 +39,21 @@ export declare class CppAssignStatement extends AssignStatement {
 export declare class CppLanguageWriter extends CLikeLanguageWriter {
     private primitivesTypes;
     protected typeConvertor: IdlNameConvertor;
+    protected classMode: 'normal' | 'detached';
+    protected currentClass: string[];
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, primitivesTypes: PrimitiveTypeList);
+    changeModeTo(mode: typeof this.classMode): void;
     getNodeName(type: IDLNode): string;
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
+    protected writeDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[], postfix?: string): void;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[]): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    writeStaticMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeFieldDeclaration(name: string, type: IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, delegationCall?: DelegationCall, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: IDLType, modifiers: FieldModifier[], getter?: {
         method: Method;
         op: () => void;
@@ -84,6 +92,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeUnionSelector(value: string, valueType: string): LanguageStatement;
     makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, convertorIndex: number): LanguageExpression;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
+    makeStaticMethodCall(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
     makeArrayInit(type: IDLContainerType): LanguageExpression;