@idlizer/core 2.1.10-arktscgen-4 → 2.1.10-arktscgen-6

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

@@ -14,26 +14,24 @@
  */
 import { warn } from 'console';
 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, TransformOnSerializeConvertor, } from "../LanguageWriters/ArgConvertors";
-import { CppNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
+import { BufferConvertor, CallbackConvertor, DateConvertor, MapConvertor, PointerConvertor, TupleConvertor, TypeAliasConvertor, AggregateConvertor, StringConvertor, ArrayConvertor, FunctionConvertor, OptionConvertor, NumberConvertor, NumericConvertor, CustomTypeConvertor, UnionConvertor, MaterializedClassConvertor, BooleanConvertor, EnumConvertor, UndefinedConvertor, VoidConvertor, ImportTypeConvertor, InterfaceConvertor, BigIntToU64Convertor, ObjectConvertor, TransformOnSerializeConvertor, } from "../LanguageWriters/ArgConvertors";
+import { StructureNameConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { CJTypeNameConvertor } from '../LanguageWriters/convertors/CJConvertors';
 import { CppConvertor } from '../LanguageWriters/convertors/CppConvertors';
 import { ETSTypeNameConvertor } from '../LanguageWriters/convertors/ETSConvertors';
-import { JavaTypeNameConvertor } from '../LanguageWriters/convertors/JavaConvertors';
 import { TSTypeNameConvertor } from '../LanguageWriters/convertors/TSConvertors';
-import { isBuilderClass } from './BuilderClass';
 import { generateSyntheticFunctionName, isImportAttr } from './idl/common';
 import { LayoutManager } from './LayoutManager';
 import { lib, query } from '../library';
 import { isMaterialized } from './isMaterialized';
-import { isInIdlizeInternal } from '../idlize';
 import { isInCurrentModule } from './modules';
 import { generatorConfiguration } from '../config';
 import { KotlinTypeNameConvertor } from '../LanguageWriters/convertors/KotlinConvertors';
 import { toIdlType } from '../from-idl/deserialize';
+import { createCachedReferenceResolver } from './ReferenceResolver';
+import { toDeclaration } from './toDeclaration';
 export const lenses = {
     globals: lib.lens(lib.select.files())
         .pipe(lib.select.nodes())
@@ -79,14 +77,12 @@ export class PeerLibrary {
     get globals() {
         return query(this.asIDLLibrary(), lenses.globals);
     }
-    initSyntheticEntries(file) {
-        this._syntheticFile = file;
+    get files() {
+        return this._files;
     }
-    getSyntheticData() {
-        return this._syntheticFile.entries.filter(it => idl.isInterface(it));
-    }
-    get buildersToGenerate() {
-        return Array.from(this.builderClasses.values()).filter(it => it.needBeGenerated);
+    set files(value) {
+        this._files = value;
+        this.resolver = createCachedReferenceResolver(value);
     }
     get orderedMaterialized() {
         function accessorName(decl) {
@@ -100,16 +96,12 @@ export class PeerLibrary {
         this.interopNativeModule = interopNativeModule;
         this.useMemoM3 = useMemoM3;
         this.layout = LayoutManager.Empty();
-        this._syntheticFile = idl.createFile([]);
-        this.files = [];
+        this._files = [];
         this.auxFiles = [];
-        this.builderClasses = new Map();
+        this.resolver = createCachedReferenceResolver([]);
         this.materializedClasses = new Map();
         this.name = "";
         this.customComponentMethods = [];
-        this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
-        this.interopNameConvertorInstance = new CppNameConvertor(this);
-        this._useFallback = true;
     }
     createLanguageWriter(language) {
         return createLanguageWriter(language !== null && language !== void 0 ? language : this.language, this);
@@ -118,7 +110,6 @@ export class PeerLibrary {
         switch (language) {
             case Language.TS: return new TSTypeNameConvertor(this);
             case Language.ARKTS: return new ETSTypeNameConvertor(this);
-            case Language.JAVA: return new JavaTypeNameConvertor(this);
             case Language.CJ: return new CJTypeNameConvertor(this);
             case Language.CPP: return new CppConvertor(this);
             case Language.KOTLIN: return new KotlinTypeNameConvertor(this);
@@ -145,8 +136,11 @@ export class PeerLibrary {
     }
     createContinuationCallbackReference(continuationType) {
         const continuationParameters = this.createContinuationParameters(continuationType);
-        const syntheticName = generateSyntheticFunctionName(continuationParameters, idl.IDLVoidType);
-        return idl.createReferenceType(syntheticName);
+        const syntheticName = generateSyntheticFunctionName(continuationParameters, idl.IDLVoidType, { nameConvertor: new StructureNameConvertor(this) });
+        const primaryReference = idl.createReferenceType(`synthetic.${syntheticName}`);
+        if (this.resolveTypeReference(primaryReference, { unresolvedOk: true }))
+            return primaryReference;
+        return idl.createReferenceType(`synthetic.synthetic_${syntheticName}`);
     }
     getCurrentContext() {
         return this.context;
@@ -158,126 +152,10 @@ export class PeerLibrary {
         return this.files.find(it => it.fileName === filename);
     }
     mapType(type) {
-        return this.targetNameConvertorInstance.convert(type);
-    }
-    enableCache() {
-        this.referenceCache = new Map();
-    }
-    resolveTypeReference(type, singleStep) {
-        var _a, _b;
-        const key = type.parent ? type : type.name; // does entry have resolve context or just FQN
-        let result = ((_a = this.referenceCache) === null || _a === void 0 ? void 0 : _a.has(key))
-            ? this.referenceCache.get(key)
-            : this.resolveTypeReferenceUncached(type, singleStep);
-        (_b = this.referenceCache) === null || _b === void 0 ? void 0 : _b.set(key, result);
-        return result;
-    }
-    resolveTypeReferenceUncached(type, singleStep) {
-        var _a, _b;
-        if ((_a = this.referenceCache) === null || _a === void 0 ? void 0 : _a.has(type))
-            return this.referenceCache.get(type);
-        let result = this.resolveNamedNode(type.name.split("."), type.parent);
-        if (!singleStep) {
-            const seen = new Set;
-            while (result) {
-                let nextResult = undefined;
-                if (idl.isImport(result))
-                    nextResult = this.resolveImport(result);
-                else if (idl.isReferenceType(result))
-                    nextResult = this.resolveNamedNode(result.name.split("."));
-                else if (idl.isTypedef(result) && idl.isReferenceType(result.type))
-                    nextResult = this.resolveNamedNode(result.type.name.split("."));
-                if (!nextResult)
-                    break;
-                if (seen.has(nextResult)) {
-                    console.warn(`Cyclic referenceType: ${type.name}, seen: [${[...seen.values()].map(idl.getFQName).join(", ")}]`);
-                    break;
-                }
-                seen.add(nextResult);
-                result = nextResult;
-            }
-        }
-        if (result && (idl.isImport(result) || idl.isNamespace(result)))
-            result = undefined;
-        (_b = this.referenceCache) === null || _b === void 0 ? void 0 : _b.set(type, result);
-        return result;
+        return this.createTypeNameConvertor(this.language).convert(type);
     }
-    disableFallback() {
-        this._useFallback = false;
-    }
-    resolveNamedNode(target, pov = undefined) {
-        const qualifiedName = target.join(".");
-        const entry = this._syntheticFile.entries.find(it => it.name === qualifiedName);
-        if (entry)
-            return entry;
-        if (1 === target.length) {
-            const predefined = this.files.flatMap(it => it.entries).filter(isInIdlizeInternal);
-            const found = predefined.find(it => it.name === target.at(-1));
-            if (found)
-                return found;
-        }
-        const corpus = this.files.concat(this.auxFiles);
-        let result = resolveNamedNode(target, pov, corpus);
-        if (result && idl.isEntry(result))
-            return result;
-        if (1 == target.length) {
-            const stdScopes = generatorConfiguration().globalPackages.map(it => it.split('.'));
-            for (const stdScope of stdScopes) {
-                result = resolveNamedNode([...stdScope, ...target], undefined, corpus);
-                if (result && idl.isEntry(result))
-                    return result;
-            }
-        }
-        // TODO: remove the next block after namespaces out of quarantine
-        if (this._useFallback) {
-            const povAsReadableString = pov
-                ? `'${idl.getFQName(pov)}'`
-                : "[root]";
-            // retry from root
-            pov = undefined;
-            const resolveds = [];
-            for (let file of this.files) {
-                result = resolveNamedNode([...file.packageClause, ...target], pov, corpus);
-                if (result && idl.isEntry(result)) {
-                    // too much spam
-                    // console.warn(`WARNING: Type reference '${qualifiedName}' is not resolved from ${povAsReadableString} but resolved from some package '${file.packageClause().join(".")}'`)
-                    resolveds.push(result);
-                }
-            }
-            // and from each namespace
-            const traverseNamespaces = (entry) => {
-                if (entry && idl.isNamespace(entry) && entry.members.length) {
-                    const resolved = resolveNamedNode([...idl.getNamespacesPathFor(entry).map(it => it.name), ...target], pov, corpus);
-                    if (resolved) {
-                        console.warn(`WARNING: Name '${qualifiedName}' is not resolved from ${povAsReadableString} but resolved from some namespace: '${idl.getNamespacesPathFor(resolved).map(obj => obj.name).join(".")}'`);
-                        resolveds.push(resolved);
-                    }
-                    entry.members.forEach(traverseNamespaces);
-                }
-            };
-            this.files.forEach(file => file.entries.forEach(traverseNamespaces));
-            for (const resolved of resolveds)
-                if (idl.isEntry(resolved))
-                    return resolved;
-        } // end of block to remove
-        return undefined;
-    }
-    resolveImport(target) {
-        let result = this.resolveNamedNode(target.clause);
-        if (result) {
-            if (idl.isReferenceType(result))
-                return this.resolveTypeReference(result);
-            if (idl.isImport(result)) {
-                if (result == target) {
-                    console.log("Self-targeted Import?");
-                    return undefined;
-                }
-                return this.resolveImport(result);
-            }
-            if (idl.isEntry(result))
-                return result;
-        }
-        return undefined;
+    resolveTypeReference(type, options) {
+        return this.resolver.resolveTypeReference(type, options);
     }
     typeConvertor(param, type, isOptionalParam = false) {
         if (isOptionalParam) {
@@ -288,17 +166,17 @@ export class PeerLibrary {
         }
         if (idl.isPrimitiveType(type)) {
             switch (type) {
-                case idl.IDLI8Type: return new NumericConvertor(param, type);
-                case idl.IDLU8Type: return new NumericConvertor(param, type);
-                case idl.IDLI16Type: return new NumericConvertor(param, type);
-                case idl.IDLU16Type: return new NumericConvertor(param, type);
-                case idl.IDLI32Type: return new NumericConvertor(param, type);
-                case idl.IDLU32Type: return new NumericConvertor(param, type);
-                case idl.IDLI64Type: return new NumericConvertor(param, type);
-                case idl.IDLU64Type: return new NumericConvertor(param, type);
-                case idl.IDLF16Type: return new NumericConvertor(param, type);
-                case idl.IDLF32Type: return new NumericConvertor(param, type);
-                case idl.IDLF64Type: return new NumericConvertor(param, type);
+                case idl.IDLI8Type: return new NumericConvertor(this, param, type);
+                case idl.IDLU8Type: return new NumericConvertor(this, param, type);
+                case idl.IDLI16Type: return new NumericConvertor(this, param, type);
+                case idl.IDLU16Type: return new NumericConvertor(this, param, type);
+                case idl.IDLI32Type: return new NumericConvertor(this, param, type);
+                case idl.IDLU32Type: return new NumericConvertor(this, param, type);
+                case idl.IDLI64Type: return new NumericConvertor(this, param, type);
+                case idl.IDLU64Type: return new NumericConvertor(this, param, type);
+                case idl.IDLF16Type: return new NumericConvertor(this, param, type);
+                case idl.IDLF32Type: return new NumericConvertor(this, param, type);
+                case idl.IDLF64Type: return new NumericConvertor(this, param, type);
                 case idl.IDLBigintType: return new BigIntToU64Convertor(param);
                 case idl.IDLSerializerBuffer: new PointerConvertor(param);
                 case idl.IDLPointerType: return new PointerConvertor(param);
@@ -321,10 +199,10 @@ export class PeerLibrary {
             // TODO: this types are not references! NativeModulePrinter must be fixed
             switch (type.name.replaceAll('%TEXT%:', '')) { // this is really bad stub, to fix legacy references
                 case 'KBoolean': return new BooleanConvertor(param);
-                case 'KInt': return new NumericConvertor(param, idl.IDLI32Type);
-                case 'KFloat': return new NumericConvertor(param, idl.IDLF32Type);
-                case 'KLong': return new NumericConvertor(param, idl.IDLI64Type);
-                case 'KDouble': return new NumericConvertor(param, idl.IDLF64Type);
+                case 'KInt': return new NumericConvertor(this, param, idl.IDLI32Type);
+                case 'KFloat': return new NumericConvertor(this, param, idl.IDLF32Type);
+                case 'KLong': return new NumericConvertor(this, param, idl.IDLI64Type);
+                case 'KDouble': return new NumericConvertor(this, param, idl.IDLF64Type);
                 case 'KStringPtr': return new StringConvertor(param);
                 case 'number': return new NumberConvertor(param);
                 case 'KPointer': return new PointerConvertor(param);
@@ -334,7 +212,7 @@ export class PeerLibrary {
             }
             const decl = this.resolveTypeReference(type);
             if (decl && isImportAttr(decl) || !decl && isImportAttr(type))
-                return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
+                return new ImportTypeConvertor(param, this.createTypeNameConvertor(this.language).convert(type));
             return this.declarationConvertor(param, type, decl);
         }
         if (idl.isUnionType(type)) {
@@ -348,7 +226,7 @@ export class PeerLibrary {
         }
         if (idl.isTypeParameterType(type)) {
             // TODO: unlikely correct.
-            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), true, `<${type.name}>`);
+            return new CustomTypeConvertor(param, this.createTypeNameConvertor(this.language).convert(type), true, `<${type.name}>`);
         }
         throw new Error(`Cannot convert: ${type.kind}`);
     }
@@ -360,24 +238,18 @@ export class PeerLibrary {
         if (customConv)
             return customConv;
         if (!declaration) {
-            return new CustomTypeConvertor(param, this.targetNameConvertorInstance.convert(type), false, this.targetNameConvertorInstance.convert(type)); // assume some predefined type
+            return new CustomTypeConvertor(param, this.createTypeNameConvertor(this.language).convert(type), false, this.createTypeNameConvertor(this.language).convert(type)); // assume some predefined type
         }
         const declarationName = declaration.name;
         if (isImportAttr(declaration)) {
-            return new ImportTypeConvertor(param, this.targetNameConvertorInstance.convert(type));
+            return new ImportTypeConvertor(param, this.createTypeNameConvertor(this.language).convert(type));
         }
         if (idl.isImport(declaration)) {
-            const target = this.resolveImport(declaration);
-            if (target && idl.isEntry(target))
-                return this.declarationConvertor(param, type, target);
-            else {
-                warn(`Unable to resolve Import ${declaration.clause.join(".")} as ${declaration.name}`);
-                return new CustomTypeConvertor(param, declaration.name, false, declaration.name);
-            }
+            throw new Error(`Unexpected declaration ${declaration.kind}`);
         }
         if (idl.hasExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize)) {
-            const targetRef = idl.createReferenceType(idl.getExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize));
-            return new TransformOnSerializeConvertor(param, this, declaration, targetRef);
+            const targetType = toIdlType("", idl.getExtAttribute(declaration, idl.IDLExtendedAttributes.TransformOnSerialize));
+            return new TransformOnSerializeConvertor(param, this, declaration, targetType);
         }
         if (idl.isEnum(declaration)) {
             return new EnumConvertor(param, declaration);
@@ -389,19 +261,17 @@ export class PeerLibrary {
             return new CallbackConvertor(this, param, declaration, this.interopNativeModule);
         }
         if (idl.isTypedef(declaration)) {
-            if (isCyclicTypeDef(declaration)) {
-                warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
-                return new CustomTypeConvertor(param, declaration.name, false, declaration.name);
-            }
+            if (forceTypedefAsResource(this, type, declaration))
+                return new ObjectConvertor(param, type);
             return new TypeAliasConvertor(this, param, declaration);
         }
         if (idl.isInterface(declaration)) {
+            if (generatorConfiguration().forceResource.includes(declaration.name)) {
+                return new ObjectConvertor(param, type);
+            }
             if (isMaterialized(declaration, this)) {
                 return new MaterializedClassConvertor(this, param, declaration);
             }
-            if (isBuilderClass(declaration)) {
-                return new ClassConvertor(this, declarationName, param, declaration);
-            }
             switch (declaration.subkind) {
                 case idl.IDLInterfaceSubkind.Interface:
                 case idl.IDLInterfaceSubkind.Class:
@@ -430,56 +300,8 @@ export class PeerLibrary {
         }
         return undefined;
     }
-    getInteropName(node) {
-        return this.interopNameConvertorInstance.convert(node);
-    }
     toDeclaration(type) {
-        switch (type) {
-            case idl.IDLAnyType: return ArkCustomObject;
-            case idl.IDLVoidType: return idl.IDLVoidType;
-            case idl.IDLUndefinedType: return idl.IDLUndefinedType;
-            case idl.IDLUnknownType: return ArkCustomObject;
-            // case idl.IDLObjectType: return ArkCustomObject
-        }
-        const typeName = idl.isNamedNode(type) ? type.name : undefined;
-        switch (typeName) {
-            case "object":
-            case "Object": return idl.IDLObjectType;
-        }
-        if (idl.isReferenceType(type)) {
-            // TODO: remove all this!
-            if (type.name === 'Date') {
-                return ArkDate;
-            }
-            if (type.name === 'AnimationRange') {
-                return ArkCustomObject;
-            }
-            if (type.name === 'Function') {
-                return ArkFunction;
-            }
-            if (type.name === 'Optional') {
-                return this.toDeclaration(type.typeArguments[0]);
-            }
-            const decl = this.resolveTypeReference(type);
-            if (!decl) {
-                warn(`undeclared type ${idl.DebugUtils.debugPrintType(type)}`);
-            }
-            if (decl && idl.isTypedef(decl) && isCyclicTypeDef(decl)) {
-                warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
-                return ArkCustomObject;
-            }
-            if (decl && idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize)) {
-                const type = toIdlType("", idl.getExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize));
-                return this.toDeclaration(type);
-            }
-            return !decl ? ArkCustomObject // assume some builtin type
-                : idl.isTypedef(decl) ? this.toDeclaration(decl.type)
-                    : decl;
-        }
-        if (isImportAttr(type)) {
-            return ArkCustomObject;
-        }
-        return type;
+        return toDeclaration(type, this);
     }
     setFileLayout(strategy) {
         this.layout = new LayoutManager(strategy);
@@ -499,7 +321,21 @@ export const ArkCustomObject = idl.IDLCustomObjectType;
 export function cleanPrefix(name, prefix) {
     return name.replace(prefix, "");
 }
-function isCyclicTypeDef(decl) {
-    return idl.isReferenceType(decl.type) && idl.isNamedNode(decl.type) && decl.type.name == decl.name;
+export function forceTypedefAsResource(resolver, type, decl) {
+    if (generatorConfiguration().forceResource.includes(idl.getFQName(decl)))
+        return true;
+    if (isCyclicTypeDef(resolver, decl)) {
+        warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
+        return true;
+    }
+    return false;
+}
+function isCyclicTypeDef(resolver, decl) {
+    let foundCycle = false;
+    idl.forEachChild(decl, (node) => {
+        if (idl.isReferenceType(node) && resolver.resolveTypeReference(node) === decl)
+            foundCycle = true;
+    });
+    return foundCycle;
 }
 //# sourceMappingURL=PeerLibrary.js.map

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

@@ -1,9 +1,14 @@
 import * as idl from '../idl';
 export interface ReferenceResolver {
-    resolveTypeReference(type: idl.IDLReferenceType, terminalImports?: boolean): idl.IDLEntry | undefined;
+    resolveTypeReference(type: idl.IDLReferenceType, options?: {
+        terminalImports?: boolean;
+        unresolvedOk?: boolean;
+    }): idl.IDLEntry | undefined;
     toDeclaration(type: idl.IDLNode): idl.IDLNode;
 }
 export declare function createEmptyReferenceResolver(): ReferenceResolver;
 /** Please do not store any global instances */
 export declare function createAlternativeReferenceResolver(mainResolver: ReferenceResolver, alternatives: Map<string, idl.IDLEntry>): ReferenceResolver;
+export declare function createAlgotithmicReferenceResolver(files: idl.IDLFile[], useFallback?: boolean): ReferenceResolver;
+export declare function createCachedReferenceResolver(files: idl.IDLFile[]): ReferenceResolver;
 //# sourceMappingURL=ReferenceResolver.d.ts.map

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

@@ -12,6 +12,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import * as idl from '../idl';
+import { getPov, resolveNamedNode } from '../resolveNamedNode';
+import { consoleWarn } from '../util';
 export function createEmptyReferenceResolver() {
     return {
         resolveTypeReference() {
@@ -25,13 +28,101 @@ export function createEmptyReferenceResolver() {
 /** Please do not store any global instances */
 export function createAlternativeReferenceResolver(mainResolver, alternatives) {
     return {
-        resolveTypeReference(type, terminalImports) {
+        resolveTypeReference(type, options) {
             var _a;
-            return (_a = mainResolver.resolveTypeReference(type, terminalImports)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
+            return (_a = mainResolver.resolveTypeReference(type, options)) !== null && _a !== void 0 ? _a : alternatives.get(type.name);
         },
         toDeclaration(type) {
             return mainResolver.toDeclaration(type);
         },
     };
 }
+export function createAlgotithmicReferenceResolver(files, useFallback = false) {
+    const resolveFallback = (type) => {
+        const target = type.name.split('.');
+        const resolveds = new Set();
+        for (let file of files) {
+            const result = resolveNamedNode([...file.packageClause, ...target], undefined, files);
+            if (result && idl.isEntry(result)) {
+                // too much spam
+                // console.warn(`WARNING: Type reference '${qualifiedName}' is not resolved from ${povAsReadableString} but resolved from some package '${file.packageClause().join(".")}'`)
+                resolveds.add(result);
+            }
+        }
+        // and from each namespace
+        const traverseNamespaces = (entry) => {
+            if (entry && idl.isNamespace(entry) && entry.members.length) {
+                const resolved = resolveNamedNode([...idl.getNamespacesPathFor(entry).map(it => it.name), ...target], undefined, files);
+                if (resolved) {
+                    console.warn(`WARNING: Name '${type.name}' resolved by fallback from some namespace: '${idl.getNamespacesPathFor(resolved).map(obj => obj.name).join(".")}'`);
+                    resolveds.add(resolved);
+                }
+                entry.members.forEach(traverseNamespaces);
+            }
+        };
+        files.forEach(file => file.entries.forEach(traverseNamespaces));
+        if (resolveds.size > 1)
+            console.error(`Resolved multiple possible declarations by ${idl.DebugUtils.debugPrintType(type)}`);
+        return resolveds.size ? resolveds.values().next().value : undefined;
+    };
+    return {
+        resolveTypeReference(type, options) {
+            var _a;
+            let result = (_a = resolveNamedNode(type.name.split("."), getPov(type), files)) !== null && _a !== void 0 ? _a : (useFallback ? resolveFallback(type) : undefined);
+            if (!(options === null || options === void 0 ? void 0 : options.terminalImports)) {
+                const seen = new Set;
+                while (result) {
+                    let nextResult = undefined;
+                    if (idl.isImport(result))
+                        nextResult = resolveNamedNode(result.clause, undefined, files);
+                    if (!nextResult)
+                        break;
+                    if (seen.has(nextResult)) {
+                        console.warn(`Cyclic referenceType: ${type.name}, seen: [${[...seen.values()].map(idl.getFQName).join(", ")}]`);
+                        break;
+                    }
+                    seen.add(nextResult);
+                    result = nextResult;
+                }
+            }
+            if (result) {
+                if (!idl.isEntry(result)) {
+                    throw new Error(`Resolved reference ${idl.DebugUtils.debugPrintType(type)} to not entry type`);
+                }
+                if (idl.isNamespace(result)) {
+                    throw new Error(`Resolved reference ${idl.DebugUtils.debugPrintType(type)} to namespace`);
+                }
+                return result;
+            }
+            return undefined;
+        },
+        toDeclaration(type) {
+            throw new Error("To declaration is not available for default references resolver");
+        }
+    };
+}
+export function createCachedReferenceResolver(files) {
+    const cache = new Map();
+    for (const file of files) {
+        idl.forEachChild(file, node => {
+            if (idl.isEnum(node) || idl.isCallback(node) || idl.isInterface(node) || idl.isTypedef(node)) {
+                const fqn = idl.getFQName(node);
+                if (cache.has(fqn))
+                    consoleWarn(`WARNING: multiple entries with FQN=${fqn} found`);
+                else
+                    cache.set(fqn, node);
+            }
+        });
+    }
+    return {
+        resolveTypeReference(type, options) {
+            if (!(options === null || options === void 0 ? void 0 : options.unresolvedOk) && !cache.has(type.name))
+                consoleWarn(`WARNING: reference ${idl.DebugUtils.debugPrintType(type)} was not found`);
+            return cache.get(type.name);
+        },
+        toDeclaration(type) {
+            throw new Error("Not implemented");
+        },
+    };
+}
 //# sourceMappingURL=ReferenceResolver.js.map

package/build/lib/src/peer-generation/idl/IdlNameConvertor.d.ts

@@ -26,6 +26,11 @@ export declare class CJDeclarationNameConvertor extends DeclarationNameConvertor
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: CJDeclarationNameConvertor;
 }
+export declare class KotlinDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl: idl.IDLInterface): string;
+    convertEnum(decl: idl.IDLEnum): string;
+    static readonly I: KotlinDeclarationNameConvertor;
+}
 export declare class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: ETSFeatureNameConvertor;
@@ -35,6 +40,7 @@ export declare class CJFeatureNameConvertor extends DeclarationNameConvertor {
     static readonly I: CJFeatureNameConvertor;
 }
 export declare class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl: idl.IDLInterface): string;
     convertEnum(decl: idl.IDLEnum): string;
     static readonly I: KotlinFeatureNameConvertor;
 }

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

@@ -14,6 +14,7 @@
  */
 import * as idl from "../../idl";
 import { Language } from "../../Language";
+import { removePoints } from "../../util";
 export class DeclarationNameConvertor {
     convertImport(decl) {
         console.warn("Imports are not implemented yet");
@@ -70,6 +71,15 @@ export class CJDeclarationNameConvertor extends DeclarationNameConvertor {
     }
 }
 CJDeclarationNameConvertor.I = new CJDeclarationNameConvertor();
+export class KotlinDeclarationNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return removePoints(idl.getQualifiedName(decl, "namespace.name"));
+    }
+    convertEnum(decl) {
+        return removePoints(idl.getQualifiedName(decl, "namespace.name"));
+    }
+}
+KotlinDeclarationNameConvertor.I = new KotlinDeclarationNameConvertor();
 export class ETSFeatureNameConvertor extends DeclarationNameConvertor {
     convertEnum(decl) {
         const namespace = idl.getNamespacesPathFor(decl).map(it => it.name);
@@ -86,25 +96,27 @@ export class CJFeatureNameConvertor extends DeclarationNameConvertor {
 }
 CJFeatureNameConvertor.I = new CJFeatureNameConvertor();
 export class KotlinFeatureNameConvertor extends DeclarationNameConvertor {
+    convertInterface(decl) {
+        return removePoints(idl.getQualifiedName(decl, "namespace.name"));
+    }
     convertEnum(decl) {
-        return decl.name;
+        return removePoints(idl.getQualifiedName(decl, "namespace.name"));
     }
 }
 KotlinFeatureNameConvertor.I = new KotlinFeatureNameConvertor();
 export function createDeclarationNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSDeclarationNameConvertor.I;
-        case Language.JAVA:
         case Language.CPP:
         case Language.TS: return DeclarationNameConvertor.I;
         case Language.CJ: CJDeclarationNameConvertor.I;
+        case Language.KOTLIN: KotlinDeclarationNameConvertor.I;
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
 export function createFeatureNameConvertor(language) {
     switch (language) {
         case Language.ARKTS: return ETSFeatureNameConvertor.I;
-        case Language.JAVA:
         case Language.CPP:
         case Language.TS: return TSFeatureNameConvertor.I;
         case Language.CJ: return CJFeatureNameConvertor.I;

package/build/lib/src/peer-generation/idl/common.d.ts

@@ -1,12 +1,16 @@
 import * as idl from "../../idl";
 import { Language } from "../../Language";
+import { IdlNameConvertor } from "../../LanguageWriters";
 export declare function generateSyntheticIdlNodeName(type: idl.IDLType): string;
 export declare function qualifiedName(decl: idl.IDLNode, languageOrDelimiter: Language | string, pattern: idl.QNPattern): string;
 export declare function collapseTypes(types: idl.IDLType[], name?: string): idl.IDLType;
-export declare function generifiedTypeName(refType: idl.IDLReferenceType | undefined, refName?: string): string | undefined;
+export declare function generifiedTypeName(refType: idl.IDLReferenceType, nameConvertor: IdlNameConvertor, refName?: string): string;
 export declare function sanitizeGenerics(genericDeclarationString: string): string;
 export declare function generateSyntheticUnionName(types: idl.IDLType[]): string;
 export declare function generateSyntheticFunctionParameterName(parameter: idl.IDLParameter): string;
-export declare function generateSyntheticFunctionName(parameters: idl.IDLParameter[], returnType: idl.IDLType, isAsync?: boolean): string;
+export declare function generateSyntheticFunctionName(parameters: idl.IDLParameter[], returnType: idl.IDLType, options?: {
+    isAsync?: boolean;
+    nameConvertor?: IdlNameConvertor;
+}): string;
 export declare function isImportAttr(decl: idl.IDLNode): boolean;
 //# sourceMappingURL=common.d.ts.map