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

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

@@ -95,14 +95,6 @@ export class FieldAccessExpression {
         return `${this.receiver}${this.nullable ? "?" : ""}.${this.field}`;
     }
 }
-export class CheckDefinedExpression {
-    constructor(value) {
-        this.value = value;
-    }
-    asString() {
-        return `${this.value} != undefined`;
-    }
-}
 export class ProxyStatement {
     constructor(cb) {
         this.cb = cb;
@@ -121,7 +113,7 @@ export class AssignStatement {
         this.options = options;
     }
     write(writer) {
-        var _a, _b;
+        var _a, _b, _c;
         if (this.isDeclared) {
             const typeSpec = ((_a = this.options) === null || _a === void 0 ? void 0 : _a.overrideTypeName)
                 ? `: ${this.options.overrideTypeName}`
@@ -133,7 +125,9 @@ export class AssignStatement {
             writer.print(`${constSpec} ${this.variableName}${typeSpec} ${initValue}`);
         }
         else {
-            writer.print(`${this.variableName} = ${(_b = this.expression) === null || _b === void 0 ? void 0 : _b.asString()}`);
+            const receiver = (_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver;
+            const withReceiver = receiver ? `${receiver}.` : "";
+            writer.print(`${withReceiver}${this.variableName} = ${(_c = this.expression) === null || _c === void 0 ? void 0 : _c.asString()}`);
         }
     }
 }
@@ -228,19 +222,6 @@ export class MultiBranchIfStatement {
         }
     }
 }
-export class CheckOptionalStatement {
-    constructor(undefinedValue, optionalExpression, doStatement) {
-        this.undefinedValue = undefinedValue;
-        this.optionalExpression = optionalExpression;
-        this.doStatement = doStatement;
-    }
-    write(writer) {
-        writer.print(`if (${this.optionalExpression.asString()} != ${this.undefinedValue})`);
-        writer.pushIndent();
-        this.doStatement.write(writer);
-        writer.popIndent();
-    }
-}
 // maybe rename or move of fix
 export class TsEnumEntityStatement {
     constructor(enumEntity, options) {
@@ -321,6 +302,7 @@ export var FieldModifier;
     FieldModifier[FieldModifier["FINAL"] = 5] = "FINAL";
     FieldModifier[FieldModifier["VOLATILE"] = 6] = "VOLATILE";
     FieldModifier[FieldModifier["INTERNAL"] = 7] = "INTERNAL";
+    FieldModifier[FieldModifier["OVERRIDE"] = 8] = "OVERRIDE";
 })(FieldModifier || (FieldModifier = {}));
 export var MethodModifier;
 (function (MethodModifier) {
@@ -509,9 +491,12 @@ export class LanguageWriter {
     makeVoid() {
         return this.makeUndefined();
     }
+    makeLambdaReturn(expr) {
+        return this.makeReturn(expr);
+    }
     makeRuntimeTypeCondition(typeVarName, equals, type, varName) {
         const op = equals ? "==" : "!=";
-        return this.makeNaryOp(op, [this.makeRuntimeType(type), this.makeString(typeVarName)]);
+        return this.makeNaryOp(op, [this.makeString(typeVarName), this.makeRuntimeType(type)]);
     }
     makeValueFromOption(value, destinationConvertor) {
         return this.makeString(`${value}!`);
@@ -548,9 +533,6 @@ export class LanguageWriter {
     nativeReceiver(nativeModule) {
         return nativeModule.name;
     }
-    makeDefinedCheck(value) {
-        return new CheckDefinedExpression(value);
-    }
     makeRuntimeTypeDefinedCheck(runtimeType) {
         return this.makeRuntimeTypeCondition(runtimeType, false, RuntimeType.UNDEFINED);
     }
@@ -575,9 +557,6 @@ export class LanguageWriter {
     makeUnionSelector(value, valueType) {
         return this.makeAssign(valueType, undefined, this.makeString(`runtimeType(${value})`), false);
     }
-    makeUnionVariantCondition(_convertor, _valueName, valueType, type, _convertorIndex, _runtimeTypeIndex) {
-        return this.makeString(`RuntimeType.${type.toUpperCase()} == ${valueType}`);
-    }
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`unsafeCast<${type}>(${value})`);
     }
@@ -616,9 +595,6 @@ export class LanguageWriter {
     writeNativeMethodDeclaration(method) {
         this.writeMethodDeclaration(method.name, method.signature);
     }
-    writeUnsafeNativeMethodDeclaration(name, signature) {
-        return;
-    }
     pushIndent() {
         this.printer.pushIndent();
     }
@@ -634,18 +610,6 @@ export class LanguageWriter {
     makeSignature(returnType, parameters) {
         return new MethodSignature(returnType, parameters.map(it => it.type));
     }
-    makeNamedSignature(returnType, parameters) {
-        return NamedMethodSignature.make(returnType, parameters.map(it => ({
-            name: it.name,
-            type: it.isOptional ? idl.createOptionalType(it.type) : it.type
-        })));
-    }
-    makeNativeMethodNamedSignature(returnType, parameters) {
-        return this.makeNamedSignature(returnType, parameters);
-    }
-    makeSerializerConstructorSignatures() {
-        return undefined;
-    }
     mapFieldModifier(modifier) {
         return `${FieldModifier[modifier].toLowerCase()}`;
     }
@@ -664,12 +628,6 @@ export class LanguageWriter {
     runtimeType(param, valueType, value) {
         this.writeStatement(this.makeAssign(valueType, idl.IDLI32Type, this.makeFunctionCall("runtimeType", [this.makeString(value)]), false));
     }
-    makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
-        return this.makeString(`(${this.makeNaryOp("||", accessors.map(it => this.makeString(`${value}!.hasOwnProperty("${it}")`))).asString()})`);
-    }
-    makeIsTypeCall(value, decl) {
-        return this.makeString(`is${decl.name}(${value})`);
-    }
     makeEnumEntity(enumEntity, options) {
         return new TsEnumEntityStatement(enumEntity, { isExport: options.isExport, isDeclare: !!options.isDeclare });
     }
@@ -687,21 +645,16 @@ export class LanguageWriter {
     makeCastCustomObject(customName, _isGenericType) {
         return this.makeString(customName);
     }
-    makeHasOwnProperty(value, _valueTypeName, property, propertyTypeName) {
+    makeHasOwnProperty(value, property, propertyTypeName) {
         const expressions = [this.makeString(`${value}.hasOwnProperty("${property}")`)];
         if (propertyTypeName) {
             expressions.push(this.makeString(`isInstanceOf("${propertyTypeName}", ${value}.${property})`));
         }
         return this.makeNaryOp("&&", expressions);
     }
-    discriminatorFromExpressions(value, runtimeType, exprs) {
-        return this.makeNaryOp("&&", [
-            this.makeNaryOp("==", [this.makeRuntimeType(runtimeType), this.makeString(`${value}_type`)]),
-            ...exprs
-        ]);
-    }
-    makeDiscriminatorConvertor(_convertor, _value, _index) {
-        return undefined;
+    discriminate(value, index, type, runtimeTypes) {
+        // return most common form, suitable for languages that don't have sum types
+        return `${value}.getSelector() == ${index}`;
     }
     makeNot(expr) {
         return this.makeString(`!(${expr.asString()})`);
@@ -720,18 +673,13 @@ export class LanguageWriter {
     makeStaticBlock(op) {
         op(this);
     }
-    instanceOf(convertor, value, _duplicateMembers) {
-        return this.makeString(`${value} instanceof ${this.getNodeName(convertor.idlType)}`);
+    instanceOf(value, type) {
+        return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
     }
     // The version of instanceOf() which does not use ArgConvertors
     typeInstanceOf(type, value, members) {
         return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
     }
-    stringifyTypeOrEmpty(type) {
-        if (type === undefined)
-            return "";
-        return this.getNodeName(type);
-    }
     /**
      * Writes `namespace <namespace> {` and adds extra indent
      * @param namespace Namespace to begin

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

@@ -58,9 +58,9 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
             case idl.IDLU64Type:
                 return 'int64';
             case idl.IDLF32Type:
-                return 'float32';
+                return 'float';
             case idl.IDLF64Type:
-                return 'float64';
+                return 'double';
             case idl.IDLNumberType:
                 return 'number';
             case idl.IDLStringType: return 'string';

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

@@ -1,6 +1,7 @@
 import * as idl from '../../idl';
 import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
-import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
+import { InteropReturnTypeConvertor } from './InteropConvertors';
 export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
     protected resolver: ReferenceResolver;
     constructor(resolver: ReferenceResolver);
@@ -22,4 +23,19 @@ export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, I
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     private callbackType;
 }
+export declare class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConvertor {
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+}
+export declare class KotlinCInteropArgConvertor implements TypeConvertor<string> {
+    convert(type: idl.IDLType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+}
 //# sourceMappingURL=KotlinConvertors.d.ts.map

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

@@ -13,7 +13,11 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
+import { isMaterialized } from '../../peer-generation/isMaterialized';
 import { convertNode, convertType } from '../nameConvertor';
+import { removePoints } from './CJConvertors';
+import { InteropReturnTypeConvertor } from './InteropConvertors';
 export class KotlinTypeNameConvertor {
     constructor(resolver) {
         this.resolver = resolver;
@@ -25,10 +29,10 @@ export class KotlinTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return node.name;
+        return removePoints(idl.getQualifiedName(node, 'namespace.name'));
     }
     convertEnum(node) {
-        return node.name;
+        return removePoints(idl.getQualifiedName(node, 'namespace.name'));
     }
     convertTypedef(node) {
         return node.name;
@@ -47,15 +51,15 @@ export class KotlinTypeNameConvertor {
         return `${this.convert(type.type)}?`;
     }
     convertUnion(type) {
-        return type.name;
+        return "Union_" + type.types.map(it => generateSyntheticIdlNodeName(it)).join("_");
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
-            return `Array<${convertType(this, type.elementType[0])}>`;
+            return `ArrayList<${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]}>`;
+            return `MutableMap<${stringes[0]}, ${stringes[1]}>`;
         }
         if (idl.IDLContainerUtils.isPromise(type)) {
             return `Any`;
@@ -76,7 +80,7 @@ export class KotlinTypeNameConvertor {
             }
         }
         if (decl) {
-            return decl.name;
+            return removePoints(idl.getQualifiedName(decl, 'namespace.name'));
         }
         return this.convert(idl.IDLCustomObjectType);
     }
@@ -125,4 +129,115 @@ export class KotlinTypeNameConvertor {
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
 }
+const KBoolean = "KBoolean";
+const KInt = "KInt";
+const KLong = "KLong";
+const KFloat = "KFloat";
+const KNativePointer = "KNativePointer";
+const KInteropNumber = "KInteropNumber";
+const KStringPtr = "KStringPtr";
+const KInteropReturnBuffer = "KInteropReturnBuffer";
+const KInteropBuffer = "KInteropBuffer";
+const KSerializerBuffer = "KSerializerBuffer";
+export class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConvertor {
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI8Type:
+            case idl.IDLU8Type:
+            case idl.IDLI16Type:
+            case idl.IDLU16Type:
+            case idl.IDLI32Type:
+            case idl.IDLU32Type:
+            case idl.IDLI64Type:
+            case idl.IDLU64Type:
+            case idl.IDLF16Type:
+            case idl.IDLF32Type:
+            case idl.IDLF64Type: return KInt;
+            case idl.IDLNumberType: return KInteropNumber;
+            case idl.IDLBooleanType: return KBoolean;
+            case idl.IDLBigintType: return KLong;
+            case idl.IDLAnyType:
+            case idl.IDLThisType:
+            case idl.IDLUndefinedType:
+            case idl.IDLUnknownType:
+            case idl.IDLObjectType:
+            case idl.IDLVoidType: return idl.IDLVoidType.name;
+            case idl.IDLBufferType: return KInteropReturnBuffer;
+            case idl.IDLStringType: return KStringPtr;
+            case idl.IDLPointerType: return KNativePointer;
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeReference(type) {
+        if (this.resolver != undefined && idl.isCallback(this.resolver.toDeclaration(type))) {
+            return KNativePointer;
+        }
+        if (type.name.endsWith("Attribute"))
+            return idl.IDLVoidType.name;
+        const decl = this.resolver.resolveTypeReference(type);
+        if (decl) {
+            // Callbacks and array types return by value
+            if (idl.isCallback(this.resolver.toDeclaration(type))) {
+                return type.name;
+            }
+            if (idl.isInterface(decl)) {
+                if (isMaterialized(decl, this.resolver)) {
+                    return KNativePointer;
+                }
+                return KInteropReturnBuffer;
+            }
+            if (idl.isEnum(decl)) {
+                return KInt;
+            }
+        }
+        return idl.IDLVoidType.name;
+    }
+}
+export class KotlinCInteropArgConvertor {
+    convert(type) {
+        return convertType(this, type);
+    }
+    convertContainer(type) {
+        throw new Error(`Cannot pass container types through interop`);
+    }
+    convertImport(type) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertTypeReferenceAsImport(type, importClause) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertOptional(type) {
+        return KNativePointer;
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            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 KInteropNumber;
+            case idl.IDLBigintType: return KLong;
+            case idl.IDLSerializerBuffer: return KSerializerBuffer;
+            case idl.IDLBooleanType:
+            case idl.IDLFunctionType: return KInt;
+            case idl.IDLStringType: return KStringPtr;
+            case idl.IDLBufferType: return KInteropBuffer;
+            case idl.IDLDate: return KLong;
+            case idl.IDLUndefinedType:
+            case idl.IDLVoidType:
+            case idl.IDLPointerType: return KNativePointer;
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeParameter(type) {
+        throw new Error("Cannot pass type parameters through interop");
+    }
+    convertTypeReference(type) {
+        throw new Error(`Cannot pass type references through interop`);
+    }
+    convertUnion(type) {
+        throw new Error("Cannot pass union types through interop");
+    }
+}
 //# sourceMappingURL=KotlinConvertors.js.map

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

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { maybeRestoreGenerics } from '../../transformers/GenericTransformer';
 import { convertNode, convertType } from '../nameConvertor';
 export class TSTypeNameConvertor {
     constructor(resolver) {
@@ -107,6 +108,11 @@ export class TSTypeNameConvertor {
                 // (can not cast MyEnum to exact MyEnum.Value1)
                 decl = decl.parent;
             }
+            let maybeRestoredGeneric = maybeRestoreGenerics(type, this.resolver);
+            if (maybeRestoredGeneric) {
+                type = maybeRestoredGeneric;
+                decl = this.resolver.resolveTypeReference(maybeRestoredGeneric);
+            }
             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`)

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

@@ -101,7 +101,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     }, setter?: {
         method: Method;
         op: () => void;
-    }): void;
+    }, initExpr?: LanguageExpression): void;
     writeGetterImplementation(method: Method, op?: (writer: this) => void): void;
     writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
@@ -121,7 +121,6 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeThrowError(message: string): LanguageStatement;
     makeTernary(condition: LanguageExpression, trueExpression: LanguageExpression, falseExpression: LanguageExpression): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;

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

@@ -227,20 +227,6 @@ class CJThrowErrorStatement {
         writer.print(`throw Exception("${this.message}")`);
     }
 }
-class CJCheckOptionalStatement {
-    constructor(undefinedValue, optionalExpression, doStatement) {
-        this.undefinedValue = undefinedValue;
-        this.optionalExpression = optionalExpression;
-        this.doStatement = doStatement;
-    }
-    write(writer) {
-        writer.print(`if (let Some(${this.optionalExpression.asString()}) <- ${this.optionalExpression.asString()}) {`);
-        writer.pushIndent();
-        this.doStatement.write(writer);
-        writer.popIndent();
-        writer.print('}');
-    }
-}
 class CJArrayResizeStatement {
     constructor(array, arrayType, length, deserializer) {
         this.array = array;
@@ -377,7 +363,7 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, modifiers, getter, setter) {
+    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let containerName = propName.concat("_container");
         let truePropName = this.escapeKeyword(propName);
         if (getter) {
@@ -387,7 +373,8 @@ export class CJLanguageWriter extends LanguageWriter {
         }
         let isStatic = modifiers.includes(FieldModifier.STATIC);
         let isMutable = !modifiers.includes(FieldModifier.READONLY);
-        this.print(`public ${isMutable ? "mut " : ""}${isStatic ? "static " : "open "}prop ${truePropName}: ${this.getNodeName(propType)}`);
+        let initializer = initExpr ? ` = ${initExpr.asString()}` : "";
+        this.print(`public ${isMutable ? "mut " : ""}${isStatic ? "static " : "open "}prop ${truePropName}: ${this.getNodeName(propType)}${initializer}`);
         if (getter) {
             this.print('{');
             this.pushIndent();
@@ -490,9 +477,6 @@ export class CJLanguageWriter extends LanguageWriter {
     makeReturn(expr) {
         return new ReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        return new CJCheckOptionalStatement("undefined", optional, doStatement);
-    }
     makeStatement(expr) {
         return new ExpressionStatement(expr);
     }

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

@@ -8,11 +8,6 @@ export declare class CLikeReturnStatement extends ReturnStatement {
     constructor(expression: LanguageExpression);
     write(writer: LanguageWriter): void;
 }
-export declare class CDefinedExpression implements LanguageExpression {
-    private value;
-    constructor(value: string);
-    asString(): string;
-}
 export declare class CLikeLoopStatement implements LanguageStatement {
     private counter;
     private limit;

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

@@ -12,7 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
 import { ExpressionStatement, LanguageWriter, Method, ReturnStatement } from "../LanguageWriter";
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
@@ -26,14 +25,6 @@ export class CLikeReturnStatement extends ReturnStatement {
         writer.print(this.expression ? `return ${this.expression.asString()};` : "return;");
     }
 }
-export class CDefinedExpression {
-    constructor(value) {
-        this.value = value;
-    }
-    asString() {
-        return `${this.value} != ${PrimitiveTypeList.UndefinedTag}`;
-    }
-}
 export class CLikeLoopStatement {
     constructor(counter, limit, statement) {
         this.counter = counter;

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, DelegationCall, MethodStaticCallExpression } from "../LanguageWriter";
+import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, MakeRefOptions, Method, PrintHint, MethodModifier, MethodSignature, ObjectArgs, DelegationCall, MethodStaticCallExpression } from "../LanguageWriter";
 import { CLikeLanguageWriter } from "./CLikeLanguageWriter";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
@@ -85,12 +85,10 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeArrayAccess(value: string, indexVar: string): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
     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;
@@ -103,7 +101,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeCast(expr: LanguageExpression, node: IDLNode, options?: MakeCastOptions): LanguageExpression;
     makePointerPropertyAccessExpression(expression: string, name: string): CppPointerPropertyAccessExpression;
     writePrintLog(message: string): void;
-    makeDefinedCheck(value: string): LanguageExpression;
+    makeDefinedCheck(value: string, isTag?: boolean): LanguageExpression;
     makeSetUnionSelector(value: string, index: string): LanguageStatement;
     makeSetOptionTag(value: string, tag: LanguageExpression): LanguageStatement;
     getObjectAccessor(convertor: BaseArgConvertor, value: string, args?: ObjectArgs): string;
@@ -129,6 +127,6 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     stringifyMethodReturnType(type: IDLType, hint?: PrintHint): string;
     stringifyMethodArgType(type: IDLType, hint?: PrintHint): string;
     stringifyTypeWithReceiver(type: IDLType, receiver?: string): string;
-    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
 }
 //# sourceMappingURL=CppLanguageWriter.d.ts.map

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

@@ -12,11 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createReferenceType, forceAsNamedNode, IDLU32Type, IDLVoidType } from '../../idl';
+import { createReferenceType, forceAsNamedNode } from '../../idl';
 import { Language } from '../../Language';
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
-import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, NamedMethodSignature, StringExpression, MethodStaticCallExpression } from "../LanguageWriter";
-import { CDefinedExpression, CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
+import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, StringExpression, MethodStaticCallExpression } from "../LanguageWriter";
+import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import { RuntimeType } from "../common";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { cppKeywords } from "../../languageSpecificKeywords";
@@ -294,14 +294,11 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         return new CppAssignStatement(variableName, type, expr, isDeclared, isConst, options);
     }
     makeLambda(signature, body) {
-        throw new Error(`TBD`);
+        throw new Error(`Improve`);
     }
     makeReturn(expr) {
         return new CLikeReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        throw new Error(`TBD`);
-    }
     makeStatement(expr) {
         return new CLikeExpressionStatement(expr);
     }
@@ -314,9 +311,6 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     makeUnionSelector(value, valueType) {
         return this.makeAssign(valueType, undefined, this.makeString(`${value}.selector`), false);
     }
-    makeUnionVariantCondition(_convertor, _valueName, valueType, type, convertorIndex) {
-        return this.makeString(`${valueType} == ${convertorIndex}`);
-    }
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`${value}.value${index}`);
     }
@@ -353,8 +347,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     writePrintLog(message) {
         this.print(`printf("${message}\\n");`);
     }
-    makeDefinedCheck(value) {
-        return new CDefinedExpression(value);
+    makeDefinedCheck(value, isTag) {
+        return this.makeString(isTag ? `${value} != ${PrimitiveTypeList.UndefinedTag}`
+            : `runtimeType(${value}) != ${PrimitiveTypeList.UndefinedRuntime}`);
     }
     makeSetUnionSelector(value, index) {
         return this.makeAssign(`${value}.selector`, undefined, this.makeString(index), false);
@@ -488,16 +483,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return this.getNodeName(type);
     }
-    makeSerializerConstructorSignatures() {
-        const fromBufferCtor = new NamedMethodSignature(IDLVoidType, [
-            idl.IDLSerializerBuffer,
-            IDLU32Type,
-            createReferenceType("CallbackResourceHolder")
-        ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], undefined, [undefined, undefined, undefined, PrintHint.AsPointer]);
-        const ownedDataCtor = new NamedMethodSignature(IDLVoidType, [
-            createReferenceType("CallbackResourceHolder")
-        ], ["resourceHolder"], [`nullptr`], undefined, [undefined, PrintHint.AsPointer]);
-        return [ownedDataCtor, fromBufferCtor];
+    discriminate(value, index, type, runtimeTypes) {
+        return `${value}.selector == ${index}`;
     }
 }
 //# sourceMappingURL=CppLanguageWriter.js.map