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

package/build/lib/src/IndentedPrinter.js

@@ -12,9 +12,9 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-import * as fs from "fs";
+import * as fs from "node:fs";
 import { indentedBy } from "./util";
-import path from "path";
+import path from "node:path";
 export class IndentedPrinter {
     constructor(output = [], indent = 0) {
         this.output = output;

package/build/lib/src/Language.d.ts

@@ -10,5 +10,6 @@ export declare class Language {
     toString(): string;
     get directory(): string;
     static fromString(name: string): Language;
+    static supportNS(lang: Language): boolean;
 }
 //# sourceMappingURL=Language.d.ts.map

package/build/lib/src/Language.js

@@ -33,6 +33,14 @@ export class Language {
             default: throw new Error(`Unsupported language ${name}`);
         }
     }
+    static supportNS(lang) {
+        switch (lang.name) {
+            case "ArkTS": return true;
+            case "TS": return true;
+            case "C++": return true;
+            default: return false;
+        }
+    }
 }
 Language.TS = new Language("TS", ".ts");
 Language.ARKTS = new Language("ArkTS", ".ts"); // using .ts for ArkTS until we get rit of tsc preprocessing

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

@@ -3,9 +3,13 @@ import { Language } from "../Language";
 import { BranchStatement, ExpressionAssigner, LanguageExpression, LanguageStatement, LanguageWriter } from "./LanguageWriter";
 import { NativeModuleType, RuntimeType } from "./common";
 import { LibraryInterface } from "../LibraryInterface";
-import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PeerLibrary } from "../peer-generation/PeerLibrary";
+import { TypeConvertor } from "./nameConvertor";
+import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 export declare function getSerializerName(_library: LibraryInterface, _language: Language, declaration: idl.IDLEntry): string;
+export declare function makeETSDiscriminatorFromFields(self: LanguageWriter, convertor: {
+    targetType: (writer: LanguageWriter) => string;
+}, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
 export interface ArgConvertor {
     param: string;
     idlType: idl.IDLType;
@@ -302,6 +306,18 @@ export declare class UnionConvertor extends BaseArgConvertor {
     getObjectAccessor(language: Language, value: string, args?: Record<string, string>): string;
     unionDiscriminator(value: string, index: number, writer: LanguageWriter, duplicates: Set<string>): LanguageExpression | undefined;
 }
+export declare class ThrowsConvertor extends BaseArgConvertor {
+    private library;
+    private decl;
+    private convertor;
+    constructor(library: LibraryInterface, param: string, decl: idl.IDLInterface);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): LanguageStatement;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
 export declare class FunctionConvertor extends BaseArgConvertor {
     private library;
     constructor(library: LibraryInterface, param: string);
@@ -352,19 +368,47 @@ export declare function generateCallbackKindName(callback: idl.IDLCallback): str
 export declare function generateCallbackKindAccess(callback: idl.IDLCallback, language: Language): string;
 export declare function generateCallbackKindValue(callback: idl.IDLCallback): number;
 export declare function generateCallbackAPIArguments(library: LibraryInterface, callback: idl.IDLCallback): string[];
-export declare function maybeTransformManagedCallback(callback: idl.IDLCallback, library: ReferenceResolver): idl.IDLCallback | undefined;
 export declare class TransformOnSerializeConvertor extends BaseArgConvertor {
     protected library: PeerLibrary;
     protected managedDeclaration: idl.IDLEntry;
+    protected source: idl.IDLType;
     protected target: idl.IDLType;
     private targetConvertor;
-    constructor(param: string, library: PeerLibrary, managedDeclaration: idl.IDLEntry, target: idl.IDLType);
+    constructor(param: string, library: PeerLibrary, managedDeclaration: idl.IDLEntry, source: idl.IDLType, target: idl.IDLType);
+    getSourceType(): idl.IDLType;
+    getTargetType(): idl.IDLType;
     isPointerType(): boolean;
     nativeType(): idl.IDLType;
     convertorArg(param: string, writer: LanguageWriter): string;
+    addImport(transformerInfo: {
+        module: string;
+        ns?: string;
+        method: string;
+    }, writer: LanguageWriter): void;
     convertorSerialize(param: string, value: string, writer: LanguageWriter): LanguageStatement;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
 }
 export declare function createOutArgConvertor(library: PeerLibrary, type: idl.IDLType | undefined, otherParams: string[]): ArgConvertor | undefined;
+export declare class UnionFlattener implements TypeConvertor<idl.IDLType[]> {
+    private resolver;
+    constructor(resolver: ReferenceResolver);
+    convertImport(type: idl.IDLImport): idl.IDLType[];
+    convertUnion(type: idl.IDLUnionType): idl.IDLType[];
+    convertTypeReference(type: idl.IDLReferenceType): idl.IDLType[];
+    convertOptional(type: idl.IDLOptionalType): idl.IDLType[];
+    convertContainer(type: idl.IDLContainerType): idl.IDLType[];
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): idl.IDLType[];
+    convertPrimitiveType(type: idl.IDLPrimitiveType): idl.IDLType[];
+    convertTypeParameter(type: idl.IDLTypeParameterType): idl.IDLType[];
+}
+export declare class UnionRuntimeTypeChecker {
+    private convertors;
+    private conflictingConvertors;
+    private duplicateMembers;
+    constructor(convertors: ArgConvertor[]);
+    private checkConflicts;
+    makeDiscriminator(value: string, convertorIndex: number, writer: LanguageWriter, library: LibraryInterface, type?: idl.IDLType): LanguageExpression;
+}
+export declare function flattenUnionType(library: LibraryInterface, type: idl.IDLType): idl.IDLType;
 export {};
 //# sourceMappingURL=ArgConvertors.d.ts.map

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

@@ -17,15 +17,27 @@ import { Language } from "../Language";
 import { BlockStatement, PrintHint, StringExpression, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorConfiguration, generatorTypePrefix } from "../config";
-import { capitalize, getExtractor, entryToFunctionName as entryToFunctionName, getTransformer, hashCodeFromString, throwException, warn } from "../util";
-import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
+import { getTransformer } from "../LibraryInterface";
+import { capitalize, hashCodeFromString, throwException, warn } from "../util";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
 import { isInExternalModule } from "../peer-generation/modules";
-import { maybeRestoreGenerics } from "../transformers/GenericTransformer";
+import { getExtractor } from "../peer-generation/Extractors";
+import { maybeRestoreGenerics, maybeRestoreThrows, maybeTransformManagedCallback } from "../transformers/transformUtils";
+import { convertType, withInsideInstanceof } from "./nameConvertor";
+import { collapseTypes } from "../peer-generation/idl/common";
 export function getSerializerName(_library, _language, declaration) {
-    return entryToFunctionName(_language, declaration, "", "SerializerImpl");
+    return idl.entryToFunctionName(_language, declaration, "", "SerializerImpl");
+}
+export function makeETSDiscriminatorFromFields(self, convertor, value, accessors, duplicates) {
+    if (convertor instanceof AggregateConvertor
+        || convertor instanceof InterfaceConvertor
+        || convertor instanceof MaterializedClassConvertor
+        || convertor instanceof CustomTypeConvertor) {
+        return self.instanceOf(value, convertor.idlType);
+    }
+    return self.makeString(`${value} instanceof ${withInsideInstanceof(true, () => convertor.targetType(self))}`);
 }
 export class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
@@ -608,7 +620,7 @@ export class ArrayConvertor extends BaseArgConvertor {
 }
 export class MapConvertor extends BaseArgConvertor {
     constructor(library, param, type, keyType, valueType) {
-        super(idl.createContainerType('record', [keyType, valueType]), [RuntimeType.OBJECT], false, true, param);
+        super(idl.createContainerType('record', [keyType, valueType], { extendedAttributes: type.extendedAttributes }), [RuntimeType.OBJECT], false, true, param);
         this.library = library;
         this.keyType = keyType;
         this.valueType = valueType;
@@ -879,7 +891,7 @@ export class UnionConvertor extends BaseArgConvertor {
         return false;
     }
     convertorSerialize(param, value, printer) {
-        const convertorItems = this.memberConvertors.map((it, index) => new ConvertorItem(it, index, it.idlType));
+        const convertorItems = this.memberConvertors.map((it, index) => new ConvertorItem(it, index, getSourceType(it)));
         if (this.isIndexedDiscriminator(printer))
             return printer.makeMultiBranchCondition(convertorItems.map(it => this.makeBranch(param, value, printer, it)));
         // Make arrays type descrimination
@@ -898,7 +910,7 @@ export class UnionConvertor extends BaseArgConvertor {
         statements.push(this.makeStoreSelector(param, index, printer));
         if (!(convertor instanceof UndefinedConvertor)) {
             const varName = `${value}ForIdx${index}`;
-            statements.push(printer.makeAssign(varName, undefined, printer.makeUnionVariantCast(convertor.getObjectAccessor(printer.language, value), printer.getNodeName(convertor.idlType), convertor, index), true));
+            statements.push(printer.makeAssign(varName, undefined, printer.makeUnionVariantCast(convertor.getObjectAccessor(printer.language, value), printer.getNodeName(getSourceType(convertor)), convertor, index), true));
             statements.push(convertor.convertorSerialize(param, varName, printer));
         }
         const genericDiscriminator = withGenericDiscriminator(this.library, this.memberConvertors, value, discriminator, type, printer);
@@ -978,6 +990,55 @@ export class UnionConvertor extends BaseArgConvertor {
         return writer.makeNaryOp("||", this.memberConvertors.map((_, n) => this.unionChecker.makeDiscriminator(value, n, writer, this.library)));
     }
 }
+export class ThrowsConvertor extends BaseArgConvertor {
+    constructor(library, param, decl) {
+        super(idl.createReferenceType(decl), [RuntimeType.OBJECT], false, true, param);
+        this.library = library;
+        this.decl = decl;
+        const restoredThrow = maybeRestoreThrows(decl, library);
+        this.convertor = restoredThrow !== idl.IDLVoidType && restoredThrow !== idl.IDLThisType ? library.typeConvertor(param, restoredThrow) : undefined;
+    }
+    convertorArg(param, writer) {
+        throw new Error("Method not implemented.");
+    }
+    convertorSerialize(param, value, writer) {
+        var _a;
+        if (writer.language === Language.CPP) {
+            return writer.makeBlock([
+                writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, 'writeBoolean', [writer.makeString(`${value}.hasException`)])),
+                writer.makeCondition(writer.makeString(`${value}.hasException`), writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, 'writeException', [writer.makeString(`${value}.exception`)])), !this.convertor ? undefined : writer.makeBlock([
+                    writer.makeAssign(`${value}Value`, undefined, writer.makeString(`${value}.value`), true),
+                    (_a = this.convertor) === null || _a === void 0 ? void 0 : _a.convertorSerialize(param, `${value}Value`, writer),
+                ]))
+            ]);
+        }
+        else {
+            throw new Error("Not expected to serialize exceptions in managed, currently they're only one directional from native to managed");
+        }
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        var _a;
+        if (writer.language === Language.CPP) {
+            throw new Error("Not expected to deserialize exceptions in CPP, currently they're only one directional from native to managed");
+        }
+        else {
+            return writer.makeCondition(writer.makeMethodCall(deserializerName, 'readBoolean', []), writer.makeBlock([
+                writer.makeThrowError(writer.makeMethodCall(deserializerName, 'readException', [])),
+            ]), !this.convertor ? undefined : writer.makeBlock([
+                (_a = this.convertor) === null || _a === void 0 ? void 0 : _a.convertorDeserialize(bufferName, deserializerName, assigneer, writer),
+            ]));
+        }
+    }
+    nativeType() {
+        return idl.createReferenceType(this.decl);
+    }
+    interopType() {
+        throw new Error("ThrowsConvertor");
+    }
+    isPointerType() {
+        return true;
+    }
+}
 export class FunctionConvertor extends BaseArgConvertor {
     constructor(library, param) {
         // TODO: pass functions as integers to native side.
@@ -1160,7 +1221,7 @@ export class CallbackConvertor extends BaseArgConvertor {
                 }),
             ];
         }
-        const result = writer.makeLambda(callbackSignature, [
+        const closure = writer.makeLambda(callbackSignature, [
             writer.makeAssign(`${argsSerializer}Serializer`, idl.createReferenceType('idlize.internal.SerializerBase'), writer.makeMethodCall('SerializerBase', 'hold', []), true),
             new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `writeInt32`, [writer.makeString(`${resourceName}.resourceId`)])),
             new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `writePointer`, [writer.makeString(callName)])),
@@ -1192,9 +1253,14 @@ export class CallbackConvertor extends BaseArgConvertor {
                     writer.makeString(continuationValueName), this.decl.returnType)
                 : undefined),
         ]);
+        writer.addFeature(idl.createReferenceType('idlize.internal.resourceFinalizerRegister'));
+        statements.push(writer.makeAssign(`${bufferName}Closure`, undefined, closure, true), writer.makeStatement(writer.makeFunctionCall(`resourceFinalizerRegister`, [
+            writer.makeString(`${bufferName}Closure`),
+            writer.makeString(resourceName)
+        ])));
         return writer.makeBlock([
             ...statements,
-            assigneer(result)
+            assigneer(writer.makeString(`${bufferName}Closure`))
         ], false);
     }
     nativeType() {
@@ -1242,11 +1308,6 @@ export function generateCallbackAPIArguments(library, callback) {
     }
     return args;
 }
-export function maybeTransformManagedCallback(callback, library) {
-    if (callback.name === "CustomBuilder")
-        return library.resolveTypeReference(idl.createReferenceType("arkui.component.idlize.CustomNodeBuilder"));
-    return undefined;
-}
 class PromiseOutArgConvertor extends BaseArgConvertor {
     constructor(library, param, promise) {
         super(library.createContinuationCallbackReference(promise), [RuntimeType.FUNCTION], false, true, param);
@@ -1289,14 +1350,21 @@ class PromiseOutArgConvertor extends BaseArgConvertor {
     }
 }
 export class TransformOnSerializeConvertor extends BaseArgConvertor {
-    constructor(param, library, managedDeclaration, target) {
+    constructor(param, library, managedDeclaration, source, target) {
         const targetConvertor = library.typeConvertor(param, target);
         super(target, targetConvertor.runtimeTypes, false, targetConvertor.useArray, param);
         this.library = library;
         this.managedDeclaration = managedDeclaration;
+        this.source = source;
         this.target = target;
         this.targetConvertor = targetConvertor;
     }
+    getSourceType() {
+        return this.source;
+    }
+    getTargetType() {
+        return this.target;
+    }
     isPointerType() {
         return this.targetConvertor.isPointerType();
     }
@@ -1306,6 +1374,11 @@ export class TransformOnSerializeConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         throw new Error("Method not implemented.");
     }
+    addImport(transformerInfo, writer) {
+        transformerInfo.ns
+            ? writer.addFeature(transformerInfo.ns, transformerInfo.module)
+            : writer.addFeature(transformerInfo.method, transformerInfo.module);
+    }
     convertorSerialize(param, value, writer) {
         if (writer.language === Language.CPP) {
             return this.targetConvertor.convertorSerialize(param, value, writer);
@@ -1314,8 +1387,9 @@ export class TransformOnSerializeConvertor extends BaseArgConvertor {
             writer.addFeature(this.target);
         }
         const transformerInfo = getTransformer(this.library, this.managedDeclaration, this.target);
-        const transformCallExpression = transformerInfo.receiver
-            ? writer.makeMethodCall(transformerInfo.receiver, transformerInfo.method, [writer.makeString(value)])
+        this.addImport(transformerInfo, writer);
+        const transformCallExpression = transformerInfo.ns
+            ? writer.makeMethodCall(transformerInfo.ns, transformerInfo.method, [writer.makeString(value)])
             : writer.makeFunctionCall(transformerInfo.method, [writer.makeString(value)]);
         const statements = [
             writer.makeAssign(`${value}Transformed`, this.target, transformCallExpression, true),
@@ -1332,8 +1406,9 @@ export class TransformOnSerializeConvertor extends BaseArgConvertor {
         }
         const targetDeserialize = this.targetConvertor.convertorDeserialize(`${bufferName}D`, deserializerName, (expr) => writer.makeAssign(`${bufferName}Deserialized`, this.target, expr, true), writer);
         const transformerInfo = getTransformer(this.library, this.target, this.managedDeclaration);
-        const transformCallExpression = transformerInfo.receiver
-            ? writer.makeMethodCall(transformerInfo.receiver, transformerInfo.method, [writer.makeString(`${bufferName}Deserialized`)])
+        this.addImport(transformerInfo, writer);
+        const transformCallExpression = transformerInfo.ns
+            ? writer.makeMethodCall(transformerInfo.ns, transformerInfo.method, [writer.makeString(`${bufferName}Deserialized`)])
             : writer.makeFunctionCall(transformerInfo.method, [writer.makeString(`${bufferName}Deserialized`)]);
         return writer.makeBlock([
             targetDeserialize,
@@ -1369,7 +1444,106 @@ function withGenericDiscriminator(library, convertors, value, discriminator, typ
         return discriminator;
     writer.addFeature("typechecks", library.layout.handwrittenPackage());
     const decl = writer.resolver.resolveTypeReference(type);
-    const checkGenericFunc = entryToFunctionName(writer.language, decl, "isGeneric_", "");
+    const checkGenericFunc = idl.entryToFunctionName(writer.language, decl, "isGeneric_", "");
     return writer.makeAnd(discriminator, writer.makeFunctionCall(`typechecks.${checkGenericFunc}`, [writer.makeString(value)]));
 }
+export class UnionFlattener {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return [];
+    }
+    convertUnion(type) {
+        return type.types.flatMap(it => convertType(this, it));
+    }
+    convertTypeReference(type) {
+        const decl = this.resolver.toDeclaration(type);
+        return idl.isType(decl) && decl !== idl.IDLCustomObjectType ? convertType(this, decl) : [type];
+    }
+    convertOptional(type) {
+        return [type.type, idl.IDLUndefinedType];
+    }
+    convertContainer(type) {
+        return [type];
+    }
+    convertTypeReferenceAsImport(type, importClause) {
+        return [type];
+    }
+    convertPrimitiveType(type) {
+        return [type];
+    }
+    convertTypeParameter(type) {
+        return [type];
+    }
+}
+export class UnionRuntimeTypeChecker {
+    constructor(convertors) {
+        this.convertors = convertors;
+        this.conflictingConvertors = new Set();
+        this.duplicateMembers = new Set();
+        this.checkConflicts();
+    }
+    checkConflicts() {
+        const runtimeTypeConflicts = new Map();
+        this.convertors.forEach(conv => {
+            conv.runtimeTypes.forEach(rtType => {
+                const convertors = runtimeTypeConflicts.get(rtType);
+                if (convertors)
+                    convertors.push(conv);
+                else
+                    runtimeTypeConflicts.set(rtType, [conv]);
+            });
+        });
+        runtimeTypeConflicts.forEach((convertors, rtType) => {
+            if (convertors.length > 1) {
+                const allMembers = new Set();
+                if (rtType === RuntimeType.OBJECT) {
+                    convertors.forEach(convertor => {
+                        convertor.getMembers().forEach(member => {
+                            if (allMembers.has(member))
+                                this.duplicateMembers.add(member);
+                            allMembers.add(member);
+                        });
+                    });
+                }
+                convertors.forEach(convertor => {
+                    this.conflictingConvertors.add(convertor);
+                });
+            }
+        });
+    }
+    makeDiscriminator(value, convertorIndex, writer, library, type) {
+        let convertor = this.convertors[convertorIndex];
+        if (writer.language === Language.TS) {
+            const isArray = idl.IDLContainerUtils.isSequence(convertor.idlType);
+            if (isArray || this.conflictingConvertors.has(convertor)) {
+                // Check elements inside array
+                if (type && convertor.idlType != type) {
+                    convertor = library.typeConvertor("", type);
+                }
+                const discriminator = convertor.unionDiscriminator(value, convertorIndex, writer, this.duplicateMembers);
+                if (discriminator)
+                    return discriminator;
+            }
+        }
+        return writer.makeString(writer.discriminate(value, convertorIndex, type !== null && type !== void 0 ? type : convertor.idlType, convertor.runtimeTypes));
+    }
+}
+export function flattenUnionType(library, type) {
+    if (idl.isUnionType(type)) {
+        const unionFlattener = new UnionFlattener(library);
+        const allTypes = type.types.flatMap(it => convertType(unionFlattener, it));
+        const uniqueTypes = new Set(allTypes);
+        return uniqueTypes.size === allTypes.length ? type : collapseTypes(Array.from(uniqueTypes));
+    }
+    return type;
+}
+function getSourceType(convertor) {
+    if (convertor instanceof TransformOnSerializeConvertor) {
+        return convertor.getSourceType();
+    }
+    return convertor.idlType;
+}
 //# sourceMappingURL=ArgConvertors.js.map

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

@@ -171,6 +171,7 @@ export declare enum MethodModifier {
     OVERRIDE = 11,
     OPEN = 12
 }
+export declare const METHOD_ACCESS_MODIFIERS: Set<MethodModifier>;
 export declare enum ClassModifier {
     PUBLIC = 0,
     PRIVATE = 1,
@@ -288,7 +289,7 @@ export declare abstract class LanguageWriter {
     abstract writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
-    abstract makeThrowError(message: string): LanguageStatement;
+    abstract makeThrowError(message: string | LanguageExpression): LanguageStatement;
     abstract makeReturn(expr?: LanguageExpression): LanguageStatement;
     abstract makeRuntimeType(rt: RuntimeType): LanguageExpression;
     abstract getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
@@ -339,6 +340,8 @@ export declare abstract class LanguageWriter {
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     makeFunctionCall(name: string | LanguageExpression, params: LanguageExpression[]): LanguageExpression;
     makeMethodCall(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
+    makeFunctionReference(name: string): LanguageExpression;
+    makeMethodReference(receiver: string, method: string): LanguageExpression;
     makeThisCall(params: LanguageExpression[]): LanguageExpression;
     makeStaticMethodCall(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeFieldAccess(receiver: string, method: string, nullable?: boolean): LanguageExpression;
@@ -438,5 +441,6 @@ export type MakeAssignOptions = {
     overrideTypeName?: string;
 };
 export type ExpressionAssigner = (expression: LanguageExpression) => LanguageStatement;
+export declare function hasAccessModifier(modifiers: MethodModifier[] | undefined): boolean;
 export {};
 //# sourceMappingURL=LanguageWriter.d.ts.map

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

@@ -339,6 +339,11 @@ export var MethodModifier;
     MethodModifier[MethodModifier["OVERRIDE"] = 11] = "OVERRIDE";
     MethodModifier[MethodModifier["OPEN"] = 12] = "OPEN";
 })(MethodModifier || (MethodModifier = {}));
+export const METHOD_ACCESS_MODIFIERS = new Set([
+    MethodModifier.PUBLIC,
+    MethodModifier.PRIVATE,
+    MethodModifier.PROTECTED
+]);
 export var ClassModifier;
 (function (ClassModifier) {
     ClassModifier[ClassModifier["PUBLIC"] = 0] = "PUBLIC";
@@ -541,6 +546,12 @@ export class LanguageWriter {
     makeMethodCall(receiver, method, params, nullable) {
         return new MethodCallExpression(receiver, method, params, nullable);
     }
+    makeFunctionReference(name) {
+        return this.makeString(name);
+    }
+    makeMethodReference(receiver, method) {
+        return this.makeString(`${receiver}.${method}`);
+    }
     // Deprecated
     // Use instead declarationCall parameter in writeConstructorImplementation(...) with DelegationType.THIS
     makeThisCall(params) {
@@ -763,4 +774,8 @@ export function copyMethod(method, overrides) {
     var _a, _b, _c, _d;
     return new Method((_a = overrides.name) !== null && _a !== void 0 ? _a : method.name, (_b = overrides.signature) !== null && _b !== void 0 ? _b : method.signature, (_c = overrides.modifiers) !== null && _c !== void 0 ? _c : method.modifiers, (_d = overrides.generics) !== null && _d !== void 0 ? _d : method.generics);
 }
+export function hasAccessModifier(modifiers) {
+    const modifier = modifiers === null || modifiers === void 0 ? void 0 : modifiers.find(value => METHOD_ACCESS_MODIFIERS.has(value));
+    return modifier !== undefined;
+}
 //# sourceMappingURL=LanguageWriter.js.map

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

@@ -14,7 +14,7 @@
  */
 import * as idl from '../../idl';
 import { CJKeywords } from '../../languageSpecificKeywords';
-import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
+import { maybeRestoreThrows } from '../../transformers/transformUtils';
 import { removePoints } from '../../util';
 import { convertNode, convertType } from '../nameConvertor';
 import { InteropArgConvertor } from './InteropConvertors';
@@ -35,7 +35,7 @@ export class CJTypeNameConvertor {
         return `Option<${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)) {
@@ -96,6 +96,10 @@ export class CJTypeNameConvertor {
             return "KPointer";
         // resolve synthetic types
         const decl = this.resolver.resolveTypeReference(type);
+        let restoredThrow;
+        if (restoredThrow = maybeRestoreThrows(decl, this.resolver)) {
+            return this.convert(restoredThrow);
+        }
         if (decl && idl.isSyntheticEntry(decl)) {
             if (idl.isCallback(decl)) {
                 return this.callbackType(decl);

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

@@ -17,11 +17,11 @@ import { generatorConfiguration } from "../../config";
 import { convertNode, convertType } from "../nameConvertor";
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
 import { InteropArgConvertor } from './InteropConvertors';
-import { maybeTransformManagedCallback } from '../ArgConvertors';
 import { qualifiedName } from '../../peer-generation/idl/common';
 import { isInIdlizeInternal } from '../../idl';
 import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
 import { Language } from '../../Language';
+import { maybeRestoreThrows, maybeTransformManagedCallback } from '../../transformers/transformUtils';
 function isSubtypeTopLevelConflicted(library, node) {
     let hasConflicts = false;
     idl.forEachChild(node, (child) => {
@@ -49,6 +49,12 @@ export class GenericCppConvertor {
         throw new Error("Internal error: namespaces are not allowed on the interop layer");
     }
     convertInterface(node) {
+        let restoredThrow;
+        if (restoredThrow = maybeRestoreThrows(node, this.library)) {
+            if (restoredThrow === idl.IDLThisType)
+                restoredThrow = idl.IDLVoidType;
+            return this.make(`Throws_${this.convertNode(restoredThrow).text}`, idl.createReferenceType(node), true);
+        }
         switch (node.subkind) {
             case idl.IDLInterfaceSubkind.AnonymousInterface:
                 return node.name

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

@@ -34,6 +34,9 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         if (idl.IDLContainerUtils.isSequence(type)) {
             return isInsideInstanceof() ? `Array` : `Array<${this.convert(type.elementType[0])}>`;
         }
+        if (idl.IDLContainerUtils.isRecord(type) && idl.hasExtAttribute(type, idl.IDLExtendedAttributes.AsRecord)) {
+            return isInsideInstanceof() ? 'Record' : `Record<${this.convert(type.elementType[0])}, ${this.convert(type.elementType[1])}>`;
+        }
         return super.convertContainer(type);
     }
     convertPrimitiveType(type) {

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;