@idlizer/core 2.1.5 → 2.1.9-arktscgen-4

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/convertors/TSConvertors.d.ts

@@ -21,8 +21,10 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
-    protected mapCallback(decl: idl.IDLCallback): string;
-    protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;
+    protected createTypeSubstitution(parameters: string[] | undefined, args: idl.IDLType[] | undefined): Map<string, idl.IDLType>;
+    protected applySubstitution(subst: Map<string, idl.IDLType>, type: idl.IDLType): idl.IDLType;
+    protected mapCallback(decl: idl.IDLCallback, args?: idl.IDLType[]): string;
+    protected productType(decl: idl.IDLInterface, args: idl.IDLType[] | undefined, isTuple: boolean, includeFieldNames: boolean): string;
     protected mapFunctionType(typeArgs: string[]): string;
 }
 export declare class TSInteropArgConvertor implements TypeConvertor<string> {

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

@@ -88,19 +88,16 @@ export class TSTypeNameConvertor {
     }
     convertTypeReference(type) {
         var _a, _b;
-        if (type.name === idl.IDLObjectType.name) {
-            return type.name;
-        }
         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!
@@ -133,8 +130,9 @@ export class TSTypeNameConvertor {
         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';
@@ -171,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)}${it.isVariadic ? "[]" : ""}`);
+    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

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;
@@ -155,8 +155,13 @@ export declare class CJLanguageWriter extends LanguageWriter {
     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;
 }

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 => {
@@ -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;
@@ -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(", ")}) }`);
+            this.printer.print(`if (let Some(${receiver}) <- ${receiver}) { ${receiver}.${this.escapeKeyword(method)}(${params.join(", ")}) }`);
         }
         else {
-            super.writeMethodCall(receiver, method, params, nullable);
+            super.writeMethodCall(receiver, this.escapeKeyword(method), params, nullable);
         }
     }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
@@ -338,11 +337,27 @@ export class CJLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name, signature, modifiers) {
         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(", ")}) {`);
+    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) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}) {`);
+            this.pushIndent();
+            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++) {
+                lessArgs = lessArgs.concat(`${i == signature.args.length && idx == 0 ? '' : ', '}Option.None`);
+            }
+            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) => `${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();
@@ -401,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();
@@ -414,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 + " " : "";
-        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 ";
+        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;
@@ -432,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`);
@@ -487,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;
@@ -512,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`);
@@ -570,12 +586,12 @@ 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})`;
+        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;