@idlizer/core 2.1.10-arktscgen-7 → 2.1.10-arktscgen-10

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

@@ -15,6 +15,7 @@
 import * as idl from '../../idl';
 import { isMaterialized } from '../../peer-generation/isMaterialized';
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
+import { maybeRestoreThrows } from '../../transformers/transformUtils';
 import { convertType } from '../nameConvertor';
 const KInteropReturnBuffer = 'KInteropReturnBuffer';
 export class InteropReturnTypeConvertor {
@@ -86,6 +87,9 @@ export class InteropReturnTypeConvertor {
             if (idl.isCallback(this.resolver.toDeclaration(type))) {
                 return KInteropReturnBuffer;
             }
+            if (maybeRestoreThrows(decl, this.resolver)) {
+                return KInteropReturnBuffer;
+            }
             if (idl.isInterface(decl)) {
                 if (isMaterialized(decl, this.resolver)) {
                     return PrimitiveTypesInstance.NativePointer.getText();

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

@@ -1,10 +1,10 @@
 import * as idl from '../../idl';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
 import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
-import { InteropReturnTypeConvertor } from './InteropConvertors';
+import { InteropArgConvertor, InteropReturnTypeConvertor } from './InteropConvertors';
+import { LibraryInterface } from '../../LibraryInterface';
 export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
+    protected library: LibraryInterface;
+    constructor(library: LibraryInterface);
     convert(node: idl.IDLNode): string;
     convertNamespace(node: idl.IDLNamespace): string;
     convertInterface(node: idl.IDLInterface): string;
@@ -21,7 +21,12 @@ export declare class KotlinTypeNameConvertor implements NodeConvertor<string>, I
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
-    private callbackType;
+    private mangleTopLevel;
+    private mapCallback;
+}
+export declare class KotlinInteropArgConvertor extends InteropArgConvertor {
+    convertContainer(type: idl.IDLContainerType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
 export declare class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConvertor {
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;

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

@@ -13,14 +13,37 @@
  * 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 '../../util';
-import { InteropReturnTypeConvertor } from './InteropConvertors';
+import { InteropArgConvertor, InteropReturnTypeConvertor } from './InteropConvertors';
+import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
+import { isDeclaredInCurrentFile, LayoutNodeRole } from '../../peer-generation/LayoutManager';
+import { Language } from '../../Language';
+import { maybeRestoreThrows } from '../../transformers/transformUtils';
+const KBoolean = "KBoolean";
+const KByte = "KByte";
+const KShort = "KShort";
+const KUShort = "KUShort";
+const KInt = "KInt";
+const KUInt = "KUInt";
+const KLong = "KLong";
+const KULong = "KULong";
+const KFloat = "KFloat";
+const KDouble = "KDouble";
+const KNativePointer = "KNativePointer";
+const KStringPtr = "KStringPtr";
+const KInteropReturnBuffer = "KInteropReturnBuffer";
+const KInteropBuffer = "KInteropBuffer";
+const KSerializerBuffer = "KSerializerBuffer";
+const KUint8ArrayPtr = "KUint8ArrayPtr";
+const KInt32ArrayPtr = "KInt32ArrayPtr";
+const KFloat32ArrayPtr = "KFloat32ArrayPtr";
+const Unit = "Unit";
+// used for Kotlin code
 export class KotlinTypeNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
+    constructor(library) {
+        this.library = library;
     }
     convert(node) {
         return convertNode(this, node);
@@ -29,17 +52,26 @@ export class KotlinTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return removePoints(idl.getQualifiedName(node, 'namespace.name'));
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : removePoints(idl.getQualifiedName(node, 'namespace.name'));
     }
     convertEnum(node) {
-        return removePoints(idl.getQualifiedName(node, 'namespace.name'));
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : removePoints(idl.getQualifiedName(node, 'namespace.name'));
     }
     convertTypedef(node) {
-        return node.name;
+        var _a;
+        if (idl.isSyntheticEntry(node)) {
+            return this.convert(node.type);
+        }
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : removePoints(idl.getQualifiedName(node, 'namespace.name'));
     }
     convertCallback(node) {
-        const params = node.parameters.map(it => `${it.name}: ${this.convert(it.type)}${it.isOptional ? "?" : ""}`);
-        return `(${params.join(", ")}) -> ${this.convert(node.returnType)}`;
+        var _a;
+        if (idl.isSyntheticEntry(node)) {
+            return this.mapCallback(node);
+        }
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : removePoints(idl.getQualifiedName(node, 'namespace.name'));
     }
     convertMethod(node) {
         return node.name;
@@ -51,7 +83,7 @@ export class KotlinTypeNameConvertor {
         return `${this.convert(type.type)}?`;
     }
     convertUnion(type) {
-        return "Union_" + type.types.map(it => generateSyntheticIdlNodeName(it)).join("_");
+        return "Union_" + type.types.map(it => idl.generateSyntheticIdlNodeName(it)).join("_");
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
@@ -78,14 +110,22 @@ export class KotlinTypeNameConvertor {
         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);
-            }
-        }
+        var _a;
+        const decl = this.library.resolveTypeReference(type);
         if (decl) {
-            return removePoints(idl.getQualifiedName(decl, 'namespace.name'));
+            if (idl.isSyntheticEntry(decl)) {
+                if (idl.isCallback(decl)) {
+                    return this.mapCallback(decl);
+                }
+                if (idl.isTypedef(decl)) {
+                    return this.convert(decl.type);
+                }
+            }
+            let restoredThrow;
+            if (restoredThrow = maybeRestoreThrows(decl, this.library)) {
+                return this.convert(restoredThrow);
+            }
+            return (_a = this.mangleTopLevel(decl)) !== null && _a !== void 0 ? _a : removePoints(idl.getQualifiedName(decl, 'namespace.name'));
         }
         return this.convert(idl.IDLCustomObjectType);
     }
@@ -103,7 +143,7 @@ export class KotlinTypeNameConvertor {
             case idl.IDLUndefinedType: return 'Nothing?';
             case idl.IDLPointerType: return 'KPointer';
             case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
-            case idl.IDLVoidType: return 'Unit';
+            case idl.IDLVoidType: return Unit;
             case idl.IDLBooleanType: return 'Boolean';
             case idl.IDLI8Type: return 'Byte';
             case idl.IDLU8Type: return 'UByte';
@@ -125,39 +165,85 @@ export class KotlinTypeNameConvertor {
             case idl.IDLBufferType:
                 return 'NativeBuffer';
             case idl.IDLInteropReturnBufferType:
-                return `KInteropReturnBuffer`;
+                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)}`);
+    mangleTopLevel(decl) {
+        if (!isDeclaredInCurrentFile(this.library.layout, { node: decl, role: LayoutNodeRole.INTERFACE }) && isTopLevelConflicted(this.library, Language.KOTLIN, decl)) {
+            const namespaces = idl.getNamespacesPathFor(decl);
+            if (namespaces.length === 0) {
+                return idl.getQualifiedName(decl, "package.namespace.name").replaceAll('.', '_');
+            }
+            const [rootNamespace, ...otherNamespaces] = idl.getNamespacesPathFor(decl);
+            const mangledRoot = idl.getQualifiedName(rootNamespace, "package.namespace.name").replaceAll('.', '_');
+            return [mangledRoot, ...otherNamespaces, decl.name].join(".");
+        }
+        return undefined;
+    }
+    mapCallback(decl) {
+        const params = decl.parameters.map(it => `${it.name}: ${this.convert(it.type)}${it.isOptional ? "?" : ""}`);
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
 }
-const KBoolean = "KBoolean";
-const KInt = "KInt";
-const KLong = "KLong";
-const KFloat = "KFloat";
-const KDouble = "KDouble";
-const KNativePointer = "KNativePointer";
-const KStringPtr = "KStringPtr";
-const KInteropReturnBuffer = "KInteropReturnBuffer";
-const KInteropBuffer = "KInteropBuffer";
-const KSerializerBuffer = "KSerializerBuffer";
+// used for Kotlin code
+export class KotlinInteropArgConvertor extends InteropArgConvertor {
+    convertContainer(type) {
+        switch (type.elementType[0]) {
+            case idl.IDLU8Type: return KUint8ArrayPtr;
+            case idl.IDLI32Type: return KInt32ArrayPtr;
+            case idl.IDLF32Type: return KFloat32ArrayPtr;
+        }
+        throw new Error(`Cannot pass container types through interop`);
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI8Type: return KByte;
+            case idl.IDLU8Type: return KByte;
+            case idl.IDLI16Type: return KShort;
+            case idl.IDLU16Type: return KUShort;
+            case idl.IDLI32Type: return KInt;
+            case idl.IDLU32Type: return KUInt;
+            case idl.IDLI64Type: return KLong;
+            case idl.IDLU64Type: return KULong;
+            case idl.IDLF32Type: return KFloat;
+            case idl.IDLF64Type: return KDouble;
+            case idl.IDLNumberType: return KDouble;
+            case idl.IDLBooleanType: {
+                // small trick to hide all casts Boolean <=> KBoolean in a NativeModule
+                return "Boolean";
+            }
+            case idl.IDLObjectType: {
+                // unsupported case for now, implementation returns Unit (analogue of void) instead of a real object
+                return "Any";
+            }
+            case idl.IDLBigintType: return KLong;
+            case idl.IDLSerializerBuffer: return KSerializerBuffer;
+            case idl.IDLFunctionType: return KInt;
+            case idl.IDLStringType: return KStringPtr;
+            case idl.IDLBufferType: return KInteropBuffer;
+            case idl.IDLInteropReturnBufferType: return KInteropReturnBuffer;
+            case idl.IDLDate: return KLong;
+            case idl.IDLVoidType: return Unit;
+            case idl.IDLPointerType: return KNativePointer;
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+}
+// used for C code
 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.IDLI8Type: return KByte;
+            case idl.IDLU8Type: return KByte;
+            case idl.IDLI16Type: return KShort;
+            case idl.IDLU16Type: return KShort;
+            case idl.IDLI32Type: return KInt;
+            case idl.IDLU32Type: return KInt;
+            case idl.IDLI64Type: return KLong;
+            case idl.IDLU64Type: return KLong;
+            case idl.IDLF32Type: return KFloat;
+            case idl.IDLF64Type: return KDouble;
             case idl.IDLNumberType: return KDouble;
             case idl.IDLBooleanType: return KBoolean;
             case idl.IDLBigintType: return KLong;
@@ -168,22 +254,20 @@ export class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConverto
             case idl.IDLObjectType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
             case idl.IDLBufferType: return KInteropReturnBuffer;
+            case idl.IDLInteropReturnBufferType: 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;
+                return KInteropReturnBuffer;
             }
             if (idl.isInterface(decl)) {
                 if (isMaterialized(decl, this.resolver)) {
@@ -198,6 +282,7 @@ export class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConverto
         return idl.IDLVoidType.name;
     }
 }
+// used for C code
 export class KotlinCInteropArgConvertor {
     convert(type) {
         return convertType(this, type);
@@ -216,22 +301,24 @@ export class KotlinCInteropArgConvertor {
     }
     convertPrimitiveType(type) {
         switch (type) {
-            case idl.IDLI64Type: return KLong;
-            case idl.IDLU64Type: return KLong;
+            case idl.IDLI8Type: return KByte;
+            case idl.IDLU8Type: return KByte;
+            case idl.IDLI16Type: return KShort;
+            case idl.IDLU16Type: return KShort;
             case idl.IDLI32Type: return KInt;
             case idl.IDLU32Type: return KInt;
+            case idl.IDLI64Type: return KLong;
+            case idl.IDLU64Type: return KLong;
             case idl.IDLF32Type: return KFloat;
             case idl.IDLF64Type: return KDouble;
             case idl.IDLNumberType: return KDouble;
+            case idl.IDLBooleanType: return KBoolean;
             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`);

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

@@ -16,7 +16,7 @@ import * as idl from '../../idl';
 import { Language } from '../../Language';
 import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
 import { isDeclaredInCurrentFile, LayoutNodeRole } from '../../peer-generation/LayoutManager';
-import { maybeRestoreGenerics } from '../../transformers/GenericTransformer';
+import { maybeRestoreGenerics, maybeRestoreThrows } from '../../transformers/transformUtils';
 import { convertNode, convertType, isInsideInstanceof, withInsideInstanceof } from '../nameConvertor';
 export class TSTypeNameConvertor {
     constructor(library) {
@@ -128,6 +128,10 @@ export class TSTypeNameConvertor {
                     return this.productType(decl, type.typeArguments, isTuple, !isTuple);
                 }
             }
+            let restoredThrow;
+            if (restoredThrow = maybeRestoreThrows(decl, this.library)) {
+                return this.convert(restoredThrow);
+            }
             // FIXME: isEnumMember is not TYPE!
             if (decl && idl.isEnumMember(decl) && decl.parent) {
                 // when `interface A { field?: MyEnum.Value1 }` is generated, it is not possible

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

@@ -1,9 +1,8 @@
 import { Language } from "../Language";
 import { LibraryInterface } from "../LibraryInterface";
-import { PeerLibrary } from "../peer-generation/PeerLibrary";
 import { LanguageWriter } from "./LanguageWriter";
 import { IdlNameConvertor } from "./nameConvertor";
 export * from "./nameConvertor";
 export declare function createLanguageWriter(language: Language, library: LibraryInterface, nameConvertor?: IdlNameConvertor): LanguageWriter;
-export declare function createInteropArgConvertor(language: Language, library: PeerLibrary): IdlNameConvertor;
+export declare function createInteropArgConvertor(language: Language): IdlNameConvertor;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,10 +1,24 @@
+/*
+ * 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 { IndentedPrinter } from "../IndentedPrinter";
 import { Language } from "../Language";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { CJIDLTypeToForeignStringConvertor, CJInteropArgConvertor, CJTypeNameConvertor } from "./convertors/CJConvertors";
 import { CppInteropArgConvertor, CppConvertor } from "./convertors/CppConvertors";
 import { ETSInteropArgConvertor, ETSTypeNameConvertor } from "./convertors/ETSConvertors";
-import { KotlinTypeNameConvertor } from "./convertors/KotlinConvertors";
+import { KotlinInteropArgConvertor, KotlinTypeNameConvertor } from "./convertors/KotlinConvertors";
 import { TSInteropArgConvertor, TSTypeNameConvertor } from "./convertors/TSConvertors";
 import { CJLanguageWriter } from "./writers/CJLanguageWriter";
 import { CppLanguageWriter } from "./writers/CppLanguageWriter";
@@ -23,13 +37,13 @@ export function createLanguageWriter(language, library, nameConvertor) {
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
-export function createInteropArgConvertor(language, library) {
+export function createInteropArgConvertor(language) {
     switch (language) {
         case Language.TS: return new TSInteropArgConvertor();
         case Language.ARKTS: return new ETSInteropArgConvertor();
         case Language.CPP: return CppInteropArgConvertor.INSTANCE;
         case Language.CJ: return new CJInteropArgConvertor();
-        case Language.KOTLIN: return new KotlinTypeNameConvertor(library);
+        case Language.KOTLIN: return new KotlinInteropArgConvertor();
     }
     throw new Error(`InteropArgConvertor for language ${language} not implemented`);
 }

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

@@ -120,7 +120,7 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeArrayAccess(value: string, indexVar: string): LanguageExpression;
     makeRuntimeTypeCondition(typeVarName: string, equals: boolean, type: RuntimeType, varName: string): LanguageExpression;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
-    makeThrowError(message: string): LanguageStatement;
+    makeThrowError(message: string | LanguageExpression): LanguageStatement;
     makeTernary(condition: LanguageExpression, trueExpression: LanguageExpression, falseExpression: LanguageExpression): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;

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

@@ -220,11 +220,11 @@ export class CJEnumEntityStatement {
     }
 }
 class CJThrowErrorStatement {
-    constructor(message) {
-        this.message = message;
+    constructor(exception) {
+        this.exception = exception;
     }
     write(writer) {
-        writer.print(`throw Exception("${this.message}")`);
+        writer.print(`throw ${this.exception.asString()}`);
     }
 }
 class CJArrayResizeStatement {
@@ -466,6 +466,8 @@ export class CJLanguageWriter extends LanguageWriter {
         return new CJLambdaExpression(this, signature, this.resolver, body);
     }
     makeThrowError(message) {
+        if (typeof message === 'string')
+            message = this.makeString(`Exception("${message}")`);
         return new CJThrowErrorStatement(message);
     }
     makeTernary(condition, trueExpression, falseExpression) {

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

@@ -24,7 +24,7 @@ export declare abstract class CLikeLanguageWriter extends LanguageWriter {
     protected constructor(printer: IndentedPrinter, resolver: ReferenceResolver, language: Language);
     writeFunctionDeclaration(name: string, signature: MethodSignature): void;
     writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
-    makeThrowError(message: string): LanguageStatement;
+    makeThrowError(message: string | LanguageExpression): LanguageStatement;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;

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

@@ -54,11 +54,11 @@ export class CLikeExpressionStatement extends ExpressionStatement {
     }
 }
 class CLikeThrowErrorStatement {
-    constructor(message) {
-        this.message = message;
+    constructor(exception) {
+        this.exception = exception;
     }
     write(writer) {
-        writer.print(`throw new Error("${this.message}");`);
+        writer.print(`throw ${this.exception.asString()};`);
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -75,6 +75,8 @@ export class CLikeLanguageWriter extends LanguageWriter {
         this.writeMethodImplementation(new Method(name, signature), op);
     }
     makeThrowError(message) {
+        if (typeof message === 'string')
+            message = this.makeString(`new Error("${message}")`);
         return new CLikeThrowErrorStatement(message);
     }
     makeEquals(args) {

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

@@ -83,7 +83,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeThis(): LanguageExpression;
     makeNull(): LanguageExpression;
     makeValueFromOption(value: string): LanguageExpression;
-    makeThrowError(message: string): LanguageStatement;
+    makeThrowError(message: string | LanguageExpression): LanguageStatement;
     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;
@@ -129,6 +129,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     stringifyMethodReturnType(type: IDLType, hint?: PrintHint): string;
     stringifyMethodArgType(type: IDLType, hint?: PrintHint): string;
     stringifyTypeWithReceiver(type: IDLType, receiver?: string): string;
+    makeMethodReference(receiver: string, method: string): LanguageExpression;
     discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
 }
 //# sourceMappingURL=CppLanguageWriter.d.ts.map

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

@@ -153,11 +153,11 @@ class CppEnumEntityStatement {
     }
 }
 class CPPThrowErrorStatement {
-    constructor(message) {
-        this.message = message;
+    constructor(exception) {
+        this.exception = exception;
     }
     write(writer) {
-        writer.print(`INTEROP_FATAL("${this.message}");`);
+        writer.print(`${this.exception.asString()};`);
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -294,6 +294,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         return this.makeString(`${value}.value`);
     }
     makeThrowError(message) {
+        if (typeof message === 'string')
+            message = this.makeString(`INTEROP_FATAL("${message}")`);
         return new CPPThrowErrorStatement(message);
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
@@ -489,6 +491,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return this.getNodeName(type);
     }
+    makeMethodReference(receiver, method) {
+        return this.makeString(`${receiver}::${method}`);
+    }
     discriminate(value, index, type, runtimeTypes) {
         return `${value}.selector == ${index}`;
     }

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

@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { BlockStatement, LambdaExpression, MethodModifier } from "../LanguageWriter";
+import { BlockStatement, LambdaExpression, MethodModifier, } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
 import { IDLThisType } from '../../idl';
-import { AggregateConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor } from "../ArgConvertors";
+import { makeETSDiscriminatorFromFields, } from "../ArgConvertors";
 import * as idl from '../../idl';
 import { withInsideInstanceof } from "../nameConvertor";
 import { Language } from "../../Language";
@@ -174,13 +174,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
             : this.makeMethodCall(enumName, 'fromValue', [value]);
     }
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
-        if (convertor instanceof AggregateConvertor
-            || convertor instanceof InterfaceConvertor
-            || convertor instanceof MaterializedClassConvertor
-            || convertor instanceof CustomTypeConvertor) {
-            return this.instanceOf(value, convertor.idlType);
-        }
-        return this.makeString(`${value} instanceof ${withInsideInstanceof(true, () => convertor.targetType(this))}`);
+        return makeETSDiscriminatorFromFields(this, convertor, value, accessors, duplicates);
     }
     makeValueFromOption(value, destinationConvertor) {
         if (idl.isEnum(this.resolver.toDeclaration(destinationConvertor.nativeType()))) {
@@ -229,7 +223,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // The explicit cast forces ui2abc to call valueOf on an int, which fails the compilation
         // TODO Fix this cast
         if (bitness === 8)
-            return `(${value}).toChar()`;
+            return `(${value}).toByte()`;
         return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? true : false`; }

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

@@ -28,8 +28,8 @@ export declare class KotlinEnumWithGetter implements LanguageStatement {
     write(writer: LanguageWriter): void;
 }
 export declare class KotlinThrowErrorStatement implements LanguageStatement {
-    message: string;
-    constructor(message: string);
+    exception: LanguageExpression;
+    constructor(exception: LanguageExpression);
     write(writer: LanguageWriter): void;
 }
 export declare class KotlinLoopStatement implements LanguageStatement {
@@ -105,7 +105,7 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     makeNull(): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
-    makeThrowError(message: string): LanguageStatement;
+    makeThrowError(message: string | LanguageExpression): LanguageStatement;
     makeReturn(expr: LanguageExpression): LanguageStatement;
     makeLambdaReturn(expr: LanguageExpression): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
@@ -147,8 +147,10 @@ export declare class KotlinLanguageWriter extends LanguageWriter {
     castToInt(value: string, bitness: 8 | 32): string;
     makeCallIsObject(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
+    makeFunctionReference(name: string): LanguageExpression;
+    makeMethodReference(receiver: string, method: string): LanguageExpression;
     escapeKeyword(keyword: string): string;
-    makeStaticBlock(op: (writer: LanguageWriter) => void): void;
+    writeStaticEntitiesBlock(op: (writer: LanguageWriter) => void): void;
     pushNamespace(namespace: string, options: NamespaceOptions): void;
     popNamespace(options: {
         ident: boolean;