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

package/build/lib/src/idl.js

@@ -72,6 +72,7 @@ export var IDLExtendedAttributes;
     IDLExtendedAttributes["NativeModule"] = "NativeModule";
     IDLExtendedAttributes["Optional"] = "Optional";
     IDLExtendedAttributes["OriginalEnumMemberName"] = "OriginalEnumMemberName";
+    IDLExtendedAttributes["OriginalGenericName"] = "OriginalGenericName";
     IDLExtendedAttributes["Predefined"] = "Predefined";
     IDLExtendedAttributes["Protected"] = "Protected";
     IDLExtendedAttributes["Synthetic"] = "Synthetic";
@@ -183,11 +184,11 @@ export function forEachChild(node, cbEnter, cbLeave) {
     cleanup === null || cleanup === void 0 ? void 0 : cleanup();
 }
 /** Updates tree in place! */
-function updateEachChild(node, op, cbLeave) {
+export function updateEachChild(node, op, cbLeave) {
     var _a;
     const old = node;
     node = op(old);
-    if (node.kind !== old.kind) {
+    if (node.kind !== old.kind && !(isType(old) && isType(node))) {
         throw new Error("Kinds must be the same!");
     }
     switch (node.kind) {
@@ -640,7 +641,18 @@ export function createConstant(name, type, value, nodeInitializer = {}) {
 }
 export function clone(node) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
-    const make = (node) => node;
+    const make = (newnode) => {
+        if (node.nodeLocation) {
+            newnode.nodeLocation = node.nodeLocation;
+        }
+        if (node.nameLocation) {
+            newnode.nameLocation = node.nameLocation;
+        }
+        if (node.valueLocation) {
+            newnode.valueLocation = node.valueLocation;
+        }
+        return newnode;
+    };
     const get = (node) => node;
     switch (node.kind) {
         case IDLKind.Interface: {

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

@@ -12,6 +12,9 @@ export * from "./util";
 export * from "./rand_utils";
 export * from "./IndentedPrinter";
 export * from "./LibraryInterface";
+export * from "./diagnostictypes";
+export * from "./diagnosticmessages";
+export * from "./formatter";
 export * from "./LanguageWriters/LanguageWriter";
 export * from "./LanguageWriters/ArgConvertors";
 export * from "./LanguageWriters/common";
@@ -22,12 +25,14 @@ export * from "./LanguageWriters/convertors/ETSConvertors";
 export * from "./LanguageWriters/convertors/JavaConvertors";
 export * from "./LanguageWriters/convertors/CJConvertors";
 export * from "./LanguageWriters/convertors/InteropConvertors";
+export * from "./LanguageWriters/convertors/KotlinConvertors";
 export * from "./LanguageWriters/writers/CJLanguageWriter";
 export * from "./LanguageWriters/writers/CLikeLanguageWriter";
 export * from "./LanguageWriters/writers/CppLanguageWriter";
 export * from "./LanguageWriters/writers/JavaLanguageWriter";
 export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
+export * from "./LanguageWriters/writers/KotlinLanguageWriter";
 export * from "./LanguageWriters/nameConvertor";
 export * from "./peer-generation/idl/IdlNameConvertor";
 export * from "./peer-generation/LayoutManager";
@@ -40,11 +45,12 @@ export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/modules";
 export * from "./peer-generation/isMaterialized";
-export * from "./peer-generation/isExternalType";
 export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
+export * from "./transformers/FqnTransformer";
+export * from "./transformers/GenericTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

package/build/lib/src/index.js

@@ -26,6 +26,9 @@ export * from "./util";
 export * from "./rand_utils";
 export * from "./IndentedPrinter";
 export * from "./LibraryInterface";
+export * from "./diagnostictypes";
+export * from "./diagnosticmessages";
+export * from "./formatter";
 export * from "./LanguageWriters/LanguageWriter";
 export * from "./LanguageWriters/ArgConvertors";
 export * from "./LanguageWriters/common";
@@ -36,12 +39,14 @@ export * from "./LanguageWriters/convertors/ETSConvertors";
 export * from "./LanguageWriters/convertors/JavaConvertors";
 export * from "./LanguageWriters/convertors/CJConvertors";
 export * from "./LanguageWriters/convertors/InteropConvertors";
+export * from "./LanguageWriters/convertors/KotlinConvertors";
 export * from "./LanguageWriters/writers/CJLanguageWriter";
 export * from "./LanguageWriters/writers/CLikeLanguageWriter";
 export * from "./LanguageWriters/writers/CppLanguageWriter";
 export * from "./LanguageWriters/writers/JavaLanguageWriter";
 export * from "./LanguageWriters/writers/TsLanguageWriter";
 export * from "./LanguageWriters/writers/ETSLanguageWriter";
+export * from "./LanguageWriters/writers/KotlinLanguageWriter";
 export * from "./LanguageWriters/nameConvertor";
 export * from "./peer-generation/idl/IdlNameConvertor";
 export * from "./peer-generation/LayoutManager";
@@ -54,11 +59,12 @@ export * from "./peer-generation/BuilderClass";
 export * from "./peer-generation/Materialized";
 export * from "./peer-generation/modules";
 export * from "./peer-generation/isMaterialized";
-export * from "./peer-generation/isExternalType";
 export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
+export * from "./transformers/FqnTransformer";
+export * from "./transformers/GenericTransformer";
 export * from "./LanguageWriters";
 export * from "./peer-generation/ReferenceResolver";
 export * from "./peer-generation/idl/common";

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

@@ -1,9 +1,9 @@
 import * as idl from '../idl';
+import { Language } from '../Language';
 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 +14,10 @@ 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;
@@ -63,6 +47,6 @@ export declare class MaterializedClass implements PeerClassBase {
 }
 export declare function createDestroyPeerMethod(clazz: MaterializedClass): MaterializedMethod | undefined;
 export declare function getInternalClassName(name: string): string;
-export declare function getInternalClassQualifiedName(target: idl.IDLEntry, pattern?: idl.QNPattern): string;
+export declare function getInternalClassQualifiedName(target: idl.IDLEntry, pattern?: idl.QNPattern, language?: Language): string;
 export declare function getMaterializedFileName(name: string): string;
 //# sourceMappingURL=Materialized.d.ts.map

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;
@@ -83,6 +42,7 @@ export class MaterializedMethod extends PeerMethod {
                 method: copyMethod(this.method, {
                     modifiers: ((_b = this.method.modifiers) !== null && _b !== void 0 ? _b : [])
                         .filter(it => it !== MethodModifier.PUBLIC)
+                        .filter(it => it !== MethodModifier.OVERRIDE)
                         .concat([MethodModifier.PRIVATE])
                 })
             });
@@ -96,19 +56,10 @@ export class MaterializedMethod extends PeerMethod {
         const method = copyMethod(this.method, { signature: signature });
         return copyMaterializedMethod(this, { method: method });
     }
-    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);
-    copied.setSameOverloadIndex(method);
-    return copied;
+    return new MaterializedMethod(method.sig, method.originalParentName, method.implementationParentName, method.returnType, method.isCallSignature, (_a = overrides.method) !== null && _a !== void 0 ? _a : method.method);
 }
 export class MaterializedClass {
     constructor(decl, className, isInterface, isStaticMaterialized, superClass, interfaces, generics, fields, ctors, // zero size when used for global functions
@@ -128,16 +79,12 @@ export class MaterializedClass {
         this.needBeGenerated = needBeGenerated;
         this.taggedMethods = taggedMethods;
         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,13 +97,13 @@ 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`;
 }
-export function getInternalClassQualifiedName(target, pattern = "package.namespace.name") {
-    return getInternalClassName(qualifiedName(target, ".", pattern));
+export function getInternalClassQualifiedName(target, pattern = "package.namespace.name", language) {
+    return getInternalClassName(qualifiedName(target, language !== null && language !== void 0 ? language : ".", pattern));
 }
 export function getMaterializedFileName(name) {
     const pascalCase = name.split('_').map(x => capitalize(x)).join('');

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/PeerLibrary.js

@@ -17,7 +17,7 @@ import * as idl from '../idl';
 import { resolveNamedNode } from '../resolveNamedNode';
 import { Language } from '../Language';
 import { createLanguageWriter } from '../LanguageWriters';
-import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, ExternalTypeConvertor, } from "../LanguageWriters/ArgConvertors";
+import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ClassConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, } from "../LanguageWriters/ArgConvertors";
 import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
@@ -32,7 +32,6 @@ import { isMaterialized } from './isMaterialized';
 import { isInIdlizeInternal } from '../idlize';
 import { isInCurrentModule } from './modules';
 import { generatorConfiguration } from '../config';
-import { isExternalType } from './isExternalType';
 import { KotlinTypeNameConvertor } from '../LanguageWriters/convertors/KotlinConvertors';
 export const lenses = {
     globals: lib.lens(lib.select.files())
@@ -392,9 +391,6 @@ export class PeerLibrary {
             return new TypeAliasConvertor(this, param, declaration);
         }
         if (idl.isInterface(declaration)) {
-            if (isExternalType(declaration, this)) {
-                return new ExternalTypeConvertor(this, param, declaration);
-            }
             if (isMaterialized(declaration, this)) {
                 return new MaterializedClassConvertor(this, param, declaration);
             }

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

@@ -1,36 +1,34 @@
+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 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;
-    static markAndGroupOverloads(methods: PeerMethod[]): PeerMethod[];
-    setSameOverloadIndex(copyFrom: PeerMethod): void;
+    constructor(sig: PeerMethodSignature, originalParentName: string, returnType: IDLType, isCallSignature: boolean, method: Method);
+    argConvertors(library: PeerLibrary): ArgConvertor[];
+    argAndOutConvertors(library: PeerLibrary): ArgConvertor[];
 }
 //# sourceMappingURL=PeerMethod.d.ts.map

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

@@ -1,101 +1,91 @@
-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";
+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;
+    }
+    static generateOverloadPostfix(decl) {
+        if (!decl.parent)
+            return ``;
+        let sameNamed = [];
+        if (idl.isMethod(decl) || idl.isProperty(decl)) {
+            let members = [];
+            if (idl.isInterface(decl.parent))
+                members = [...decl.parent.properties, ...decl.parent.methods];
+            else if (idl.isNamespace(decl.parent))
+                members = decl.parent.members;
+            else if (idl.isFile(decl.parent))
+                members = decl.parent.entries.filter(idl.isMethod);
+            sameNamed = members.filter(it => it.name === decl.name);
+        }
+        else if (idl.isConstructor(decl) && idl.isInterface(decl.parent)) {
+            sameNamed = decl.parent.constructors;
+        }
+        else if (idl.isCallable(decl) && idl.isInterface(decl.parent)) {
+            sameNamed = decl.parent.callables;
+        }
+        else {
+            throw new Error("unexpected type of declaration");
+        }
+        return sameNamed.length > 1 ? sameNamed.indexOf(decl).toString() : '';
+    }
+    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;
-    }
-    static markAndGroupOverloads(methods) {
-        let groupedMethods = [];
-        for (const peerMethod of methods) {
-            if (isDefined(peerMethod.overloadIndex))
-                continue;
-            const sameNamedMethods = methods.filter(it => it.method.name === peerMethod.method.name);
-            if (sameNamedMethods.length > 1)
-                sameNamedMethods.forEach((it, index) => it.overloadIndex = index);
-            groupedMethods = groupedMethods.concat(sameNamedMethods);
-        }
-        return groupedMethods;
-    }
-    setSameOverloadIndex(copyFrom) {
-        this.overloadIndex = copyFrom.overloadIndex;
+        // 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;
     }
 }
 //# sourceMappingURL=PeerMethod.js.map

package/build/lib/src/peer-generation/idl/common.js

@@ -38,7 +38,7 @@ export function qualifiedName(decl, languageOrDelimiter, pattern) {
         throw new Error("internal error, name required for no-named node");
     const delimiter = typeof languageOrDelimiter === "string"
         ? languageOrDelimiter
-        : (languageOrDelimiter === Language.CPP ? '_' : '.');
+        : ([Language.CPP, Language.CJ, Language.KOTLIN].includes(languageOrDelimiter) ? '_' : '.');
     if (!idl.isEntry(decl))
         throw new Error(`Expected to have an IDLEntry, got ${idl.IDLKind[decl.kind]}`);
     return idl.getQualifiedName(decl, pattern).split(".").join(delimiter);

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

@@ -15,7 +15,6 @@
 import { generatorConfiguration } from '../config';
 import * as idl from '../idl';
 import { isBuilderClass } from './BuilderClass';
-import { isExternalType } from './isExternalType';
 import { getSuper } from './getSuperType';
 export function isMaterialized(declaration, resolver) {
     var _a;
@@ -45,9 +44,6 @@ export function isMaterialized(declaration, resolver) {
     if (generatorConfiguration().ignoreMaterialized.includes(declaration.name)) {
         return false;
     }
-    if (isExternalType(declaration, resolver)) {
-        return false;
-    }
     // A materialized class is a class or an interface with methods
     // excluding components and related classes
     if (declaration.methods.length > 0 || declaration.constructors.length > 0)

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

@@ -2,6 +2,7 @@ import { ModuleConfiguration } from "../config";
 import * as idl from "../idl";
 export declare function isInModule(node: idl.IDLNode, module: ModuleConfiguration): boolean;
 export declare function isInModule(packageName: string, module: ModuleConfiguration): boolean;
+export declare function isInExternalModule(node: idl.IDLNode): boolean;
 export declare function getModuleFor(node: idl.IDLNode): ModuleConfiguration;
 export declare function getModuleFor(packageName: string): ModuleConfiguration;
 export declare function currentModule(): ModuleConfiguration;