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

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

@@ -5,6 +5,7 @@ import { NativeModuleType, RuntimeType } from "./common";
 import { LibraryInterface } from "../LibraryInterface";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PeerLibrary } from "../peer-generation/PeerLibrary";
+import { PeerMethodSignature } from "../peer-generation/PeerMethod";
 export declare function getSerializerName(declaration: idl.IDLEntry): string;
 export interface ArgConvertor {
     param: string;
@@ -26,7 +27,7 @@ export interface ArgConvertor {
     getObjectAccessor(languge: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
 }
 export declare function isDirectConvertedType(originalType: idl.IDLType | undefined, library: PeerLibrary): boolean;
-export declare function isVMContextMethod(method: Method): boolean;
+export declare function isVMContextMethod(method: Method | PeerMethodSignature): boolean;
 export declare function isDirectMethod(method: Method, library: PeerLibrary): boolean;
 export declare abstract class BaseArgConvertor implements ArgConvertor {
     idlType: idl.IDLType;
@@ -355,4 +356,5 @@ export declare function generateCallbackKindAccess(callback: idl.IDLCallback, la
 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 function createOutArgConvertor(library: PeerLibrary, type: idl.IDLType | undefined, otherParams: string[]): ArgConvertor | undefined;
 //# sourceMappingURL=ArgConvertors.d.ts.map

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

@@ -24,6 +24,7 @@ import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolv
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { qualifiedName } from "../peer-generation/idl/common";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
+import { PeerMethodSignature } from "../peer-generation/PeerMethod";
 export function getSerializerName(declaration) {
     return `${idl.getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
 }
@@ -76,7 +77,8 @@ export function isDirectConvertedType(originalType, library) {
 }
 export function isVMContextMethod(method) {
     var _a, _b;
-    return !!idl.asPromise(method.signature.returnType) ||
+    const isPromise = !!idl.asPromise(method instanceof PeerMethodSignature ? method.returnType : method.signature.returnType);
+    return isPromise ||
         !!((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS)) ||
         !!((_b = method.modifiers) === null || _b === void 0 ? void 0 : _b.includes(MethodModifier.FORCE_CONTEXT)) ||
         generatorConfiguration().forceContext.includes(method.name);
@@ -1294,4 +1296,50 @@ export function maybeTransformManagedCallback(callback, library) {
         return library.resolveTypeReference(idl.createReferenceType("CustomNodeBuilder"));
     return undefined;
 }
+class PromiseOutArgConvertor extends BaseArgConvertor {
+    constructor(library, param, promise) {
+        super(library.createContinuationCallbackReference(promise), [RuntimeType.FUNCTION], false, true, param);
+        this.library = library;
+        this.promise = promise;
+        this.isOut = true;
+        const type = this.idlType;
+        const callbackEntry = library.resolveTypeReference(type);
+        if (!callbackEntry)
+            throw new Error(`Internal error: no callback for ${type.name} resolved`);
+        this.callback = callbackEntry;
+        this.callbackConvertor = new CallbackConvertor(library, param, this.callback, this.library.interopNativeModule);
+    }
+    convertorArg(param, writer) {
+        return this.callbackConvertor.convertorArg(param, writer);
+    }
+    convertorSerialize(param, value, writer) {
+        if (writer.language == Language.CPP) {
+            this.callbackConvertor.convertorSerialize(param, value, writer);
+            return;
+        }
+        const serializeCallback = idl.isVoidType(this.promise.elementType[0])
+            ? writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallbackForPromiseVoid`, [])
+            : writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallbackForPromise<${writer.getNodeName(this.promise.elementType[0])}>`, []);
+        writer.writeStatement(writer.makeAssign(value, undefined, writer.language == Language.CJ ? writer.makeString(serializeCallback.asString().concat('.promise')) : writer.makeTupleAccess(serializeCallback.asString(), 0), true));
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return this.callbackConvertor.convertorDeserialize(bufferName, deserializerName, assigneer, writer);
+    }
+    nativeType() {
+        return this.idlType;
+    }
+    isPointerType() {
+        return true;
+    }
+}
+export function createOutArgConvertor(library, type, otherParams) {
+    if (type && idl.isContainerType(type) && idl.IDLContainerUtils.isPromise(type)) {
+        const param = (entropy) => `outputArgumentForReturningPromise${entropy || ''}`;
+        let paramEntropy = 0;
+        while (otherParams === null || otherParams === void 0 ? void 0 : otherParams.includes(param(paramEntropy)))
+            ++paramEntropy;
+        return new PromiseOutArgConvertor(library, param(paramEntropy), type);
+    }
+    return undefined;
+}
 //# sourceMappingURL=ArgConvertors.js.map

package/build/lib/src/peer-generation/Materialized.d.ts

@@ -2,8 +2,7 @@ import * as idl from '../idl';
 import { ArgConvertor } from '../LanguageWriters/ArgConvertors';
 import { Field, Method } from '../LanguageWriters/LanguageWriter';
 import { PeerClassBase } from './PeerClass';
-import { PeerMethod } from './PeerMethod';
-import { ReferenceResolver } from './ReferenceResolver';
+import { PeerMethod, PeerMethodSignature } from './PeerMethod';
 export declare class MaterializedField {
     field: Field;
     argConvertor: ArgConvertor;
@@ -14,25 +13,11 @@ export declare class MaterializedField {
 }
 export declare class MaterializedMethod extends PeerMethod {
     implementationParentName: string;
-    outArgConvertor?: ArgConvertor | undefined;
-    constructor(originalParentName: string, implementationParentName: string, argConvertors: ArgConvertor[], returnType: idl.IDLType, isCallSignature: boolean, method: Method, outArgConvertor?: ArgConvertor | undefined);
-    get peerMethodName(): string;
-    get implNamespaceName(): string;
-    get toStringName(): string;
-    dummyReturnValue(resolver: ReferenceResolver): string | undefined;
-    get receiverType(): string;
-    get apiCall(): string;
-    get apiKind(): string;
-    generateReceiver(): {
-        argName: string;
-        argType: string;
-    } | undefined;
-    getImplementationName(): string;
+    constructor(sig: PeerMethodSignature, originalParentName: string, implementationParentName: string, returnType: idl.IDLType, isCallSignature: boolean, method: Method);
     tsReturnType(): idl.IDLType | undefined;
     getPrivateMethod(): MaterializedMethod;
     withReturnType(returnType: idl.IDLType): MaterializedMethod;
     setOverloadIndex(index: number): void;
-    getOverloadPostfix(): string;
 }
 export declare function copyMaterializedMethod(method: MaterializedMethod, overrides: {
     method?: Method;
@@ -54,7 +39,6 @@ export declare class MaterializedClass implements PeerClassBase {
     constructor(decl: idl.IDLInterface, className: string, isInterface: boolean, isStaticMaterialized: boolean, superClass: idl.IDLReferenceType | undefined, interfaces: idl.IDLReferenceType[] | undefined, generics: string[] | undefined, fields: MaterializedField[], ctors: MaterializedMethod[], // zero size when used for global functions
     finalizer: MaterializedMethod | undefined, // undefined when used for global functions
     methods: MaterializedMethod[], needBeGenerated?: boolean, taggedMethods?: idl.IDLMethod[]);
-    getComponentName(): string;
     getImplementationName(): string;
     generatedName(isCallSignature: boolean): string;
     private _isGlobal;

package/build/lib/src/peer-generation/Materialized.js

@@ -16,7 +16,7 @@ import * as idl from '../idl';
 import { copyMethod, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
 import { capitalize } from '../util';
 import { qualifiedName } from './idl/common';
-import { PeerMethod } from './PeerMethod';
+import { PeerMethod, PeerMethodSignature } from './PeerMethod';
 export class MaterializedField {
     constructor(field, argConvertor, outArgConvertor, isNullableOriginalTypeField, extraMethodName = undefined) {
         this.field = field;
@@ -27,50 +27,9 @@ export class MaterializedField {
     }
 }
 export class MaterializedMethod extends PeerMethod {
-    constructor(originalParentName, implementationParentName, argConvertors, returnType, isCallSignature, method, outArgConvertor) {
-        super(originalParentName, argConvertors, returnType, isCallSignature, method, outArgConvertor);
+    constructor(sig, originalParentName, implementationParentName, returnType, isCallSignature, method) {
+        super(sig, originalParentName, returnType, isCallSignature, method);
         this.implementationParentName = implementationParentName;
-        this.outArgConvertor = outArgConvertor;
-    }
-    get peerMethodName() {
-        return this.overloadedName;
-    }
-    get implNamespaceName() {
-        return `${capitalize(this.originalParentName)}Accessor`;
-    }
-    get toStringName() {
-        switch (this.method.name) {
-            case "ctor": return `new ${this.originalParentName}`;
-            case "destructor": return `delete ${this.originalParentName}`;
-            default: return super.toStringName;
-        }
-    }
-    dummyReturnValue(resolver) {
-        if (this.method.name === "ctor")
-            return `(Ark_${this.originalParentName}) 100`;
-        if (this.method.name === "getFinalizer")
-            return `fnPtr<KNativePointer>(dummyClassFinalizer)`;
-        return undefined;
-    }
-    get receiverType() {
-        return `Ark_${this.originalParentName}`;
-    }
-    get apiCall() {
-        return "GetAccessors()";
-    }
-    get apiKind() {
-        return "Accessor";
-    }
-    generateReceiver() {
-        if (!this.hasReceiver())
-            return undefined;
-        return {
-            argName: 'peer',
-            argType: `Ark_${this.originalParentName}`
-        };
-    }
-    getImplementationName() {
-        return this.implementationParentName;
     }
     tsReturnType() {
         return this.method.signature.returnType;
@@ -99,14 +58,10 @@ export class MaterializedMethod extends PeerMethod {
     setOverloadIndex(index) {
         this.overloadIndex = index;
     }
-    getOverloadPostfix() {
-        var _a;
-        return `${(_a = this.overloadIndex) !== null && _a !== void 0 ? _a : ""}`;
-    }
 }
 export function copyMaterializedMethod(method, overrides) {
     var _a;
-    const copied = new MaterializedMethod(method.originalParentName, method.implementationParentName, method.argConvertors, method.returnType, method.isCallSignature, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method, method.outArgConvertor);
+    const copied = new MaterializedMethod(method.sig, method.originalParentName, method.implementationParentName, method.returnType, method.isCallSignature, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method);
     copied.setSameOverloadIndex(method);
     return copied;
 }
@@ -130,14 +85,11 @@ export class MaterializedClass {
         this._isGlobal = false;
         PeerMethod.markAndGroupOverloads(methods);
     }
-    getComponentName() {
-        return this.className;
-    }
     getImplementationName() {
         return this.isInterface ? getInternalClassName(this.className) : this.className;
     }
     generatedName(isCallSignature) {
-        return this.className;
+        return this.getImplementationName();
     }
     setGlobalScope() {
         this._isGlobal = true;
@@ -150,7 +102,7 @@ export function createDestroyPeerMethod(clazz) {
     if (clazz.isGlobalScope() || clazz.isStaticMaterialized) {
         return undefined;
     }
-    return new MaterializedMethod(idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), [], idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
+    return new MaterializedMethod(new PeerMethodSignature(PeerMethodSignature.DESTROY, '%NEVER_USED$', [], idl.IDLVoidType, clazz.decl), idl.getQualifiedName(clazz.decl, "namespace.name").split('.').join('_'), clazz.getImplementationName(), idl.IDLVoidType, false, new Method('destroyPeer', new NamedMethodSignature(idl.IDLVoidType, [idl.createReferenceType(clazz.decl)], ['peer'])));
 }
 export function getInternalClassName(name) {
     return `${name}Internal`;

package/build/lib/src/peer-generation/PeerClass.d.ts

@@ -2,7 +2,6 @@ import { IDLFile, IDLProperty } from "../idl";
 import { PeerMethod } from "./PeerMethod";
 export interface PeerClassBase {
     generatedName(isCallSignature: boolean): string;
-    getComponentName(): string;
 }
 export declare class PeerClass implements PeerClassBase {
     readonly file: IDLFile;
@@ -10,7 +9,6 @@ export declare class PeerClass implements PeerClassBase {
     readonly originalFilename: string;
     constructor(file: IDLFile, componentName: string, originalFilename: string);
     generatedName(isCallSignature: boolean): string;
-    getComponentName(): string;
     methods: PeerMethod[];
     originalClassName: string | undefined;
     originalInterfaceName: string | undefined;

package/build/lib/src/peer-generation/PeerClass.js

@@ -13,8 +13,7 @@
  * limitations under the License.
  */
 import { IDLI32Type, IDLPointerType } from "../idl";
-import { NumericConvertor } from "../LanguageWriters/ArgConvertors";
-import { PeerMethod } from "./PeerMethod";
+import { PeerMethod, PeerMethodArg, PeerMethodSignature } from "./PeerMethod";
 import { Method, MethodModifier, NamedMethodSignature } from "../LanguageWriters/LanguageWriter";
 export class PeerClass {
     constructor(file, componentName, originalFilename) {
@@ -33,11 +32,10 @@ export class PeerClass {
     generatedName(isCallSignature) {
         return isCallSignature ? this.originalInterfaceName : this.originalClassName;
     }
-    getComponentName() {
-        return this.componentName;
-    }
 }
 export function createConstructPeerMethod(clazz) {
-    return new PeerMethod(clazz.componentName, [new NumericConvertor('id', IDLI32Type), new NumericConvertor('flags', IDLI32Type)], IDLPointerType, false, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
+    // TODO here is class FQName needed, but can not calculate if from current PeerClass data
+    const classFQN = [clazz.componentName];
+    return new PeerMethod(new PeerMethodSignature(PeerMethodSignature.CTOR, classFQN.concat(PeerMethodSignature.CTOR).join('_'), [new PeerMethodArg('id', IDLI32Type), new PeerMethodArg('flags', IDLI32Type)], IDLPointerType), clazz.componentName, IDLPointerType, false, new Method('construct', new NamedMethodSignature(IDLPointerType, [IDLI32Type, IDLI32Type], ['id', 'flags']), [MethodModifier.STATIC]));
 }
 //# sourceMappingURL=PeerClass.js.map

package/build/lib/src/peer-generation/PeerMethod.d.ts

@@ -1,35 +1,37 @@
+import * as idl from '../idl';
 import { IDLType } from "../idl";
-import { IdlNameConvertor } from "../LanguageWriters";
 import { ArgConvertor } from "../LanguageWriters/ArgConvertors";
-import { Method } from "../LanguageWriters/LanguageWriter";
-import { ReferenceResolver } from "./ReferenceResolver";
+import { Method, MethodModifier } from "../LanguageWriters/LanguageWriter";
+import { PeerLibrary } from './PeerLibrary';
+export declare class PeerMethodArg {
+    readonly name: string;
+    readonly type: idl.IDLType;
+    constructor(name: string, type: idl.IDLType);
+}
+export declare class PeerMethodSignature {
+    readonly name: string;
+    readonly fqname: string;
+    readonly args: PeerMethodArg[];
+    readonly returnType: idl.IDLType;
+    readonly context: idl.IDLEntry | undefined;
+    readonly modifiers: (MethodModifier.FORCE_CONTEXT | MethodModifier.THROWS)[];
+    constructor(name: string, fqname: string, args: PeerMethodArg[], returnType: idl.IDLType, context?: idl.IDLEntry | undefined, modifiers?: (MethodModifier.FORCE_CONTEXT | MethodModifier.THROWS)[]);
+    static stub(): PeerMethodSignature;
+    static generateOverloadPostfix(decl: idl.IDLConstructor | idl.IDLMethod | idl.IDLCallable | idl.IDLProperty): string;
+    static get CTOR(): string;
+    static get GET_FINALIZER(): string;
+    static get DESTROY(): string;
+}
 export declare class PeerMethod {
+    sig: PeerMethodSignature;
     originalParentName: string;
-    argConvertors: ArgConvertor[];
     returnType: IDLType;
     isCallSignature: boolean;
     method: Method;
-    outArgConvertor?: ArgConvertor | undefined;
     protected overloadIndex?: number;
-    constructor(originalParentName: string, argConvertors: ArgConvertor[], returnType: IDLType, isCallSignature: boolean, method: Method, outArgConvertor?: ArgConvertor | undefined);
-    get overloadedName(): string;
-    get fullMethodName(): string;
-    get peerMethodName(): string;
-    get implNamespaceName(): string;
-    get implName(): string;
-    get toStringName(): string;
-    dummyReturnValue(resolver: ReferenceResolver): string | undefined;
-    get receiverType(): string;
-    get apiCall(): string;
-    get apiKind(): string;
-    get argAndOutConvertors(): ArgConvertor[];
-    hasReceiver(): boolean;
-    generateAPIParameters(converter: IdlNameConvertor): string[];
-    generateReceiver(): {
-        argName: string;
-        argType: string;
-    } | undefined;
-    getImplementationName(): string;
+    constructor(sig: PeerMethodSignature, originalParentName: string, returnType: IDLType, isCallSignature: boolean, method: Method);
+    argConvertors(library: PeerLibrary): ArgConvertor[];
+    argAndOutConvertors(library: PeerLibrary): ArgConvertor[];
     static markAndGroupOverloads(methods: PeerMethod[]): PeerMethod[];
     setSameOverloadIndex(copyFrom: PeerMethod): void;
 }

package/build/lib/src/peer-generation/PeerMethod.js

@@ -1,86 +1,94 @@
-import { generatorTypePrefix } from "../config";
-import { asPromise } from "../idl";
-import { isVMContextMethod } from "../LanguageWriters/ArgConvertors";
-import { mangleMethodName, MethodModifier } from "../LanguageWriters/LanguageWriter";
-import { capitalize, isDefined } from "../util";
-import { PrimitiveTypesInstance } from "./PrimitiveType";
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as idl from '../idl';
+import { createOutArgConvertor } from "../LanguageWriters/ArgConvertors";
+import { MethodModifier } from "../LanguageWriters/LanguageWriter";
+import { isDefined } from "../util";
+export class PeerMethodArg {
+    constructor(name, type) {
+        this.name = name;
+        this.type = type;
+    }
+}
+export class PeerMethodSignature {
+    constructor(
+    // contextual name of method
+    name, 
+    // unique name of method (used in global scopes like interop)
+    fqname, args, returnType, context = undefined, 
+    // only modifiers affecting signature. Private, public, static and others - does not belong here
+    modifiers = []) {
+        this.name = name;
+        this.fqname = fqname;
+        this.args = args;
+        this.returnType = returnType;
+        this.context = context;
+        this.modifiers = modifiers;
+    }
+    // whilt migration we're creating PeerMethod, but in reality we shoudnt (created method does not goes through interop and does not have representation in native)
+    static stub() {
+        return new PeerMethodSignature("%STUB$", "%STUB$", [], idl.IDLVoidType, undefined);
+    }
+    static generateOverloadPostfix(decl) {
+        if (!decl.parent || !idl.isInterface(decl.parent))
+            return ``;
+        if (idl.isMethod(decl) || idl.isProperty(decl)) {
+            let sameNamed = [
+                ...decl.parent.properties,
+                ...decl.parent.methods,
+            ].filter(it => it.name === decl.name);
+            const overloadIndex = sameNamed.length > 1 ? sameNamed.indexOf(decl).toString() : '';
+            return overloadIndex;
+        }
+        if (idl.isConstructor(decl)) {
+            const sameNamed = decl.parent.constructors.filter(it => it.name === decl.name);
+            const overloadIndex = sameNamed.length > 1 ? sameNamed.indexOf(decl).toString() : '';
+            return overloadIndex;
+        }
+        if (idl.isCallable(decl)) {
+            const sameNamed = decl.parent.callables;
+            const overloadIndex = sameNamed.length > 1 ? sameNamed.indexOf(decl).toString() : '';
+            return overloadIndex;
+        }
+        throw new Error("unexpected type of declaration");
+    }
+    static get CTOR() { return "construct"; }
+    static get GET_FINALIZER() { return "getFinalizer"; }
+    static get DESTROY() { return "destroyPeer"; }
+}
 export class PeerMethod {
-    constructor(originalParentName, argConvertors, returnType, isCallSignature, method, outArgConvertor) {
+    constructor(sig, originalParentName, returnType, isCallSignature, method) {
+        var _a, _b;
+        this.sig = sig;
         this.originalParentName = originalParentName;
-        this.argConvertors = argConvertors;
         this.returnType = returnType;
         this.isCallSignature = isCallSignature;
         this.method = method;
-        this.outArgConvertor = outArgConvertor;
-    }
-    get overloadedName() {
-        return mangleMethodName(this.method, this.overloadIndex);
-    }
-    get fullMethodName() {
-        return this.isCallSignature ? this.overloadedName : this.peerMethodName;
-    }
-    get peerMethodName() {
-        const name = this.overloadedName;
-        if (!this.hasReceiver())
-            return name;
-        if (name.startsWith("set") ||
-            name.startsWith("get"))
-            return name;
-        return `set${capitalize(name)}`;
-    }
-    get implNamespaceName() {
-        return `${capitalize(this.originalParentName)}Modifier`;
-    }
-    get implName() {
-        return `${capitalize(this.overloadedName)}Impl`;
-    }
-    get toStringName() {
-        return this.method.name;
-    }
-    dummyReturnValue(resolver) {
-        return undefined;
-    }
-    get receiverType() {
-        return "Ark_NodeHandle";
-    }
-    get apiCall() {
-        return "GetNodeModifiers()";
-    }
-    get apiKind() {
-        return "Modifier";
-    }
-    get argAndOutConvertors() {
-        var _a;
-        return this.argConvertors.concat((_a = this.outArgConvertor) !== null && _a !== void 0 ? _a : []);
-    }
-    hasReceiver() {
-        var _a;
-        return !((_a = this.method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.STATIC));
-    }
-    generateAPIParameters(converter) {
-        const args = this.argAndOutConvertors.map(it => {
-            let isPointer = it.isPointerType();
-            return `${isPointer ? "const " : ""}${converter.convert(it.nativeType())}${isPointer ? "*" : ""} ${it.param}`;
-        });
-        const receiver = this.generateReceiver();
-        if (receiver)
-            args.unshift(`${receiver.argType} ${receiver.argName}`);
-        if (!!asPromise(this.method.signature.returnType))
-            args.unshift(`${generatorTypePrefix()}AsyncWorkerPtr asyncWorker`);
-        if (isVMContextMethod(this.method))
-            args.unshift(`${generatorTypePrefix()}VMContext vmContext`);
-        return args;
-    }
-    generateReceiver() {
-        if (!this.hasReceiver())
-            return undefined;
-        return {
-            argName: "node",
-            argType: PrimitiveTypesInstance.NativePointer.getText()
-        };
-    }
-    getImplementationName() {
-        return this.originalParentName;
+        // todo remove me
+        if ((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.FORCE_CONTEXT))
+            sig.modifiers.push(MethodModifier.FORCE_CONTEXT);
+        if ((_b = method.modifiers) === null || _b === void 0 ? void 0 : _b.includes(MethodModifier.THROWS))
+            sig.modifiers.push(MethodModifier.THROWS);
+    }
+    argConvertors(library) {
+        return this.sig.args.map(it => library.typeConvertor(it.name, it.type, false));
+    }
+    argAndOutConvertors(library) {
+        const convertors = this.argConvertors(library);
+        const outArgConvertor = createOutArgConvertor(library, this.sig.returnType, this.sig.args.map(it => it.name));
+        return outArgConvertor ? convertors.concat(outArgConvertor) : convertors;
     }
     static markAndGroupOverloads(methods) {
         let groupedMethods = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idlizer/core",
-  "version": "2.1.9-arktscgen-5",
+  "version": "2.1.9-arktscgen-6",
   "description": "",
   "types": "build/lib/src/index.d.ts",
   "exports": {

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

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

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

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