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

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

@@ -3,11 +3,9 @@ export * from "./idl";
 export * from "./resolveNamedNode";
 export * from "./visitor";
 export * from "./library";
-export * from "./idlize";
 export * from "./inheritance";
 export * from "./Language";
 export * from "./languageSpecificKeywords";
-export * from "./options";
 export * from "./util";
 export * from "./rand_utils";
 export * from "./IndentedPrinter";
@@ -22,14 +20,12 @@ export * from "./LanguageWriters/nameConvertor";
 export * from "./LanguageWriters/convertors/CppConvertors";
 export * from "./LanguageWriters/convertors/TSConvertors";
 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";
@@ -49,6 +45,7 @@ export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
+export * from "./peer-generation/ConflictingDeclarations";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
 export * from "./transformers/NullTransformer";

package/build/lib/src/index.js

@@ -17,11 +17,9 @@ export * from "./idl";
 export * from "./resolveNamedNode";
 export * from "./visitor";
 export * from "./library";
-export * from "./idlize";
 export * from "./inheritance";
 export * from "./Language";
 export * from "./languageSpecificKeywords";
-export * from "./options";
 export * from "./util";
 export * from "./rand_utils";
 export * from "./IndentedPrinter";
@@ -36,14 +34,12 @@ export * from "./LanguageWriters/nameConvertor";
 export * from "./LanguageWriters/convertors/CppConvertors";
 export * from "./LanguageWriters/convertors/TSConvertors";
 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";
@@ -63,6 +59,7 @@ export * from "./peer-generation/isStructureType";
 export * from "./peer-generation/isEnumType";
 export * from "./peer-generation/unions";
 export * from "./peer-generation/getSuperType";
+export * from "./peer-generation/ConflictingDeclarations";
 export * from "./transformers/FqnTransformer";
 export * from "./transformers/GenericTransformer";
 export * from "./transformers/NullTransformer";

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

@@ -1,4 +1,3 @@
-import * as ts from "typescript";
 export declare enum InheritanceRole {
     Finalizable = 0,
     PeerNode = 1,
@@ -6,7 +5,6 @@ export declare enum InheritanceRole {
     Heir = 3,
     Standalone = 4
 }
-export declare function isCommonMethodOrSubclass(typeChecker: ts.TypeChecker, decl: ts.ClassDeclaration): boolean;
 export declare function determineInheritanceRole(name: string): InheritanceRole;
 export declare function determineParentRole(name: string | undefined, parent: string | undefined): InheritanceRole;
 export declare function isCommonMethod(name: string): boolean;

package/build/lib/src/inheritance.js

@@ -12,9 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import * as ts from "typescript";
 import { generatorConfiguration } from "./config";
-import { asString, heritageDeclarations, identName } from "./util";
 export var InheritanceRole;
 (function (InheritanceRole) {
     InheritanceRole[InheritanceRole["Finalizable"] = 0] = "Finalizable";
@@ -23,21 +21,6 @@ export var InheritanceRole;
     InheritanceRole[InheritanceRole["Heir"] = 3] = "Heir";
     InheritanceRole[InheritanceRole["Standalone"] = 4] = "Standalone";
 })(InheritanceRole || (InheritanceRole = {}));
-export function isCommonMethodOrSubclass(typeChecker, decl) {
-    var _a;
-    let name = identName(decl.name);
-    let isSubclass = isRoot(name);
-    (_a = decl.heritageClauses) === null || _a === void 0 ? void 0 : _a.forEach(it => {
-        heritageDeclarations(typeChecker, it).forEach(it => {
-            let name = asString(it.name);
-            isSubclass = isSubclass || isRoot(name);
-            if (!ts.isClassDeclaration(it))
-                return isSubclass;
-            isSubclass = isSubclass || isCommonMethodOrSubclass(typeChecker, it);
-        });
-    });
-    return isSubclass;
-}
 export function determineInheritanceRole(name) {
     if (generatorConfiguration().rootComponents.includes(name))
         return InheritanceRole.Root;

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

@@ -0,0 +1,6 @@
+import * as idl from "../idl";
+import { Language } from "../Language";
+import { LibraryInterface } from "../LibraryInterface";
+export declare function findTopLevelConflicts(library: LibraryInterface, language: Language): string[];
+export declare function isTopLevelConflicted(library: LibraryInterface, language: Language, node: idl.IDLEntry): boolean;
+//# sourceMappingURL=ConflictingDeclarations.d.ts.map

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

@@ -0,0 +1,43 @@
+import * as idl from "../idl";
+import { Language } from "../Language";
+const findTopLevelConflicts_cache = new Map();
+export function findTopLevelConflicts(library, language) {
+    if (!findTopLevelConflicts_cache.has(library))
+        findTopLevelConflicts_cache.set(library, new Map);
+    const libraryCache = findTopLevelConflicts_cache.get(library);
+    if (!libraryCache.has(language))
+        libraryCache.set(language, findTopLevelConflictsUncached(library, language));
+    return libraryCache.get(language);
+}
+function findTopLevelConflictsUncached(library, language) {
+    const foundNames = new Set();
+    const conflictingNames = new Set();
+    const ignoreTypedefs = language === Language.CPP;
+    for (const file of library.files) {
+        for (const entry of file.entries) {
+            if (idl.isSyntheticEntry(entry))
+                continue;
+            if (ignoreTypedefs && idl.isTypedef(entry))
+                // for redefinitions like `typedef _Resource Resource;` - in CPP than anyway will be expanded to Resource declaration
+                continue;
+            if (idl.isCallback(entry) || idl.isInterface(entry) || idl.isTypedef(entry) || idl.isEnum(entry)) {
+                if (foundNames.has(entry.name)) {
+                    conflictingNames.add(entry.name);
+                }
+                else {
+                    foundNames.add(entry.name);
+                }
+            }
+        }
+    }
+    return Array.from(conflictingNames);
+}
+export function isTopLevelConflicted(library, language, node) {
+    const topLevelConflicts = findTopLevelConflicts(library, language);
+    while (node.parent && idl.isNamespace(node.parent)) {
+        node = node.parent;
+    }
+    return node.parent !== undefined
+        && idl.isFile(node.parent) && idl.isEntry(node) && topLevelConflicts.includes(node.name);
+}
+//# sourceMappingURL=ConflictingDeclarations.js.map

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

@@ -23,4 +23,6 @@ export declare class LayoutManager {
     handwrittenPackage(): string;
     static Empty(): LayoutManager;
 }
+export declare function wrapCurrentFileDescription<T>(description: LayoutTargetDescription, op: () => T): T;
+export declare function isDeclaredInCurrentFile(layout: LayoutManagerStrategy, over: LayoutTargetDescription): boolean;
 //# sourceMappingURL=LayoutManager.d.ts.map

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

@@ -35,4 +35,19 @@ export class LayoutManager {
         return new LayoutManager({ resolve: () => '', handwrittenPackage: () => '' });
     }
 }
+let currentGenerationDescription;
+export function wrapCurrentFileDescription(description, op) {
+    const prev = currentGenerationDescription;
+    currentGenerationDescription = description;
+    const result = op();
+    currentGenerationDescription = prev;
+    return result;
+}
+export function isDeclaredInCurrentFile(layout, over) {
+    if (!currentGenerationDescription)
+        throw new Error("Current file context is not set up. Please use `wrapCurrentFileDescription` to set up current context. That must be temporary solution until structural printers are ready");
+    if (layout.resolve(currentGenerationDescription) === layout.resolve(over))
+        return true;
+    return false;
+}
 //# sourceMappingURL=LayoutManager.js.map

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

@@ -11,6 +11,8 @@ export declare class MaterializedField {
     isNullableOriginalTypeField?: boolean | undefined;
     extraMethodName: string | undefined;
     constructor(field: Field, argConvertor: ArgConvertor, outArgConvertor?: ArgConvertor | undefined, isNullableOriginalTypeField?: boolean | undefined, extraMethodName?: string | undefined);
+    hasGetter(): boolean;
+    hasSetter(): boolean;
 }
 export declare class MaterializedMethod extends PeerMethod {
     decl: idl.IDLConstructor | idl.IDLMethod | undefined;

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

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 import * as idl from '../idl';
-import { copyMethod, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
+import { copyMethod, FieldModifier, Method, MethodModifier, NamedMethodSignature } from '../LanguageWriters/LanguageWriter';
 import { capitalize } from '../util';
 import { qualifiedName } from './idl/common';
 import { PeerMethod, PeerMethodSignature } from './PeerMethod';
@@ -25,6 +25,19 @@ export class MaterializedField {
         this.isNullableOriginalTypeField = isNullableOriginalTypeField;
         this.extraMethodName = extraMethodName;
     }
+    hasGetter() {
+        const isGetter = this.field.modifiers.includes(FieldModifier.GET);
+        const isSetter = this.field.modifiers.includes(FieldModifier.SET);
+        const isAccessor = isGetter || isSetter;
+        return !isAccessor || isGetter;
+    }
+    hasSetter() {
+        const isReadonly = this.field.modifiers.includes(FieldModifier.READONLY);
+        const isGetter = this.field.modifiers.includes(FieldModifier.GET);
+        const isSetter = this.field.modifiers.includes(FieldModifier.SET);
+        const isAccessor = isGetter || isSetter;
+        return (!isAccessor && !isReadonly) || isSetter;
+    }
 }
 export class MaterializedMethod extends PeerMethod {
     constructor(decl, sig, originalParentName, implementationParentName, returnType, isCallSignature, uniqueOverloadName, method) {

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

@@ -10273,8 +10273,6 @@ export declare class PeerLibrary implements LibraryInterface {
     readonly customComponentMethods: string[];
     createLanguageWriter(language?: Language): LanguageWriter;
     createTypeNameConvertor(language: Language): IdlNameConvertor;
-    protected readonly targetNameConvertorInstance: IdlNameConvertor;
-    private readonly interopNameConvertorInstance;
     get libraryPrefix(): string;
     createContinuationParameters(continuationType: idl.IDLType): idl.IDLParameter[];
     createContinuationCallbackReference(continuationType: idl.IDLType): idl.IDLReferenceType;
@@ -10294,7 +10292,6 @@ export declare class PeerLibrary implements LibraryInterface {
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     private customConvertor;
-    getInteropName(node: idl.IDLNode): string;
     toDeclaration(type: idl.IDLType | idl.IDLTypedef | idl.IDLCallback | idl.IDLEnum | idl.IDLInterface): idl.IDLEntry | idl.IDLType;
     setFileLayout(strategy: LayoutManagerStrategy): void;
     withFileLayout(strategy: LayoutManagerStrategy, op: () => void): void;

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

@@ -18,18 +18,16 @@ 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 { 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 { isInIdlizeInternal } from '../idl';
 import { isInCurrentModule } from './modules';
 import { generatorConfiguration } from '../config';
 import { KotlinTypeNameConvertor } from '../LanguageWriters/convertors/KotlinConvertors';
@@ -107,8 +105,6 @@ export class PeerLibrary {
         this.materializedClasses = new Map();
         this.name = "";
         this.customComponentMethods = [];
-        this.targetNameConvertorInstance = this.createTypeNameConvertor(this.language);
-        this.interopNameConvertorInstance = new CppNameConvertor(this);
         this._useFallback = true;
     }
     createLanguageWriter(language) {
@@ -118,7 +114,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);
@@ -158,7 +153,7 @@ export class PeerLibrary {
         return this.files.find(it => it.fileName === filename);
     }
     mapType(type) {
-        return this.targetNameConvertorInstance.convert(type);
+        return this.createTypeNameConvertor(this.language).convert(type);
     }
     enableCache() {
         this.referenceCache = new Map();
@@ -288,17 +283,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 +316,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 +329,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 +343,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,11 +355,11 @@ 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);
@@ -389,10 +384,8 @@ 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(type, declaration))
+                return new ObjectConvertor(param, type);
             return new TypeAliasConvertor(this, param, declaration);
         }
         if (idl.isInterface(declaration)) {
@@ -430,9 +423,6 @@ export class PeerLibrary {
         }
         return undefined;
     }
-    getInteropName(node) {
-        return this.interopNameConvertorInstance.convert(node);
-    }
     toDeclaration(type) {
         switch (type) {
             case idl.IDLAnyType: return ArkCustomObject;
@@ -464,9 +454,8 @@ export class PeerLibrary {
             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.isTypedef(decl) && forceTypedefAsResource(type, decl)) {
+                return idl.IDLObjectType;
             }
             if (decl && idl.hasExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize)) {
                 const type = toIdlType("", idl.getExtAttribute(decl, idl.IDLExtendedAttributes.TransformOnSerialize));
@@ -499,7 +488,34 @@ export const ArkCustomObject = idl.IDLCustomObjectType;
 export function cleanPrefix(name, prefix) {
     return name.replace(prefix, "");
 }
+function forceTypedefAsResource(type, decl) {
+    if (generatorConfiguration().forceResource.includes(idl.getFQName(decl)))
+        return true;
+    if (isCyclicTypeDef(decl)) {
+        warn(`Cyclic typedef: ${idl.DebugUtils.debugPrintType(type)}`);
+        return true;
+    }
+    return false;
+}
 function isCyclicTypeDef(decl) {
-    return idl.isReferenceType(decl.type) && idl.isNamedNode(decl.type) && decl.type.name == decl.name;
+    return checkCyclicType(idl.getFQName(decl), decl.type);
+}
+function checkCyclicType(fqn, type) {
+    if (idl.isReferenceType(type) && idl.isNamedNode(type) && idl.getFQName(type) == fqn)
+        return true;
+    if (idl.isOptionalType(type) && checkCyclicType(fqn, type.type))
+        return true;
+    if (idl.isUnionType(type) && checkCyclicTypes(fqn, type.types))
+        return true;
+    if (idl.isContainerType(type) && checkCyclicTypes(fqn, type.elementType))
+        return true;
+    return false;
+}
+function checkCyclicTypes(fqn, types) {
+    for (const t of types) {
+        if (checkCyclicType(fqn, t))
+            return true;
+    }
+    return false;
 }
 //# sourceMappingURL=PeerLibrary.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/util.d.ts

@@ -1,31 +1,7 @@
-import * as ts from "typescript";
 import * as idl from "./idl";
 import { Language } from './Language';
 import { LibraryInterface } from './LibraryInterface';
-export interface NameWithType {
-    name?: ts.DeclarationName;
-    type?: ts.TypeNode;
-}
-/** True if this is visible outside this file, false otherwise */
-export declare function isNodePublic(node: ts.Node): boolean;
-export declare function nameOrNull(name: ts.EntityName | ts.DeclarationName | undefined): string | undefined;
-export declare function isNamedDeclaration(node: ts.Node): node is ts.NamedDeclaration;
-export declare function asString(node: ts.Node | undefined): string;
 export declare function arrayAt<T>(array: T[] | undefined, index: number): T | undefined;
-export declare function getComment(sourceFile: ts.SourceFile, node: ts.Node): string;
-export declare function getSymbolByNode(typechecker: ts.TypeChecker, node: ts.Node): ts.Symbol | undefined;
-export declare function getDeclarationsByNode(typechecker: ts.TypeChecker, node: ts.Node): ts.Declaration[];
-export declare function findRealDeclarations(typechecker: ts.TypeChecker, node: ts.Node): ts.Declaration[];
-export declare function getExportedDeclarationNameByDecl(declaration: ts.NamedDeclaration): string | undefined;
-export declare function getExportedDeclarationNameByNode(typechecker: ts.TypeChecker, node: ts.Node): string | undefined;
-export declare function isReadonly(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isExport(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isAbstract(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isStatic(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isAsync(modifierLikes: ts.NodeArray<ts.ModifierLike> | readonly ts.Modifier[] | undefined): boolean;
-export declare function isPrivate(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function isProtected(modifierLikes: ts.NodeArray<ts.ModifierLike> | undefined): boolean;
-export declare function getLineNumberString(sourceFile: ts.SourceFile, position: number): string;
 export declare function isDefined<T>(value: T | null | undefined): value is T;
 export declare function capitalize(string: string): string;
 export declare function capitalizeConstantName(string: string): string;
@@ -35,22 +11,9 @@ export type stringOrNone = string | undefined;
 export declare function toSet(option: string | undefined): Set<string>;
 export declare function getOrPut<K, V>(map: Map<K, V>, key: K, create: (key: K) => V): V;
 export declare function indentedBy(input: string, indentedBy: number): string;
-export declare function typeOrUndefined(type: ts.TypeNode): ts.TypeNode;
 export declare function forEachExpanding<T>(array: T[], action: (element: T) => void): void;
-export declare function isTypeParamSuitableType(type: ts.TypeNode): boolean;
-export declare function heritageTypes(typechecker: ts.TypeChecker, clause: ts.HeritageClause): ts.TypeReferenceNode[];
-export declare function heritageDeclarations(typechecker: ts.TypeChecker, clause: ts.HeritageClause): ts.NamedDeclaration[];
-export declare function typeName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): string | undefined;
-export declare function typeEntityName(type: ts.TypeReferenceNode | ts.TypeQueryNode | ts.ImportTypeNode): ts.EntityName | undefined;
 export declare function zip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
 export declare function zipStrip<A, B>(left: readonly A[], right: readonly B[]): [A, B][];
-export declare function identNameWithNamespace(node: ts.Node, language: Language): string;
-export declare function identName(node: ts.Node | undefined): string | undefined;
-export declare function identString(node: ts.Identifier | ts.PrivateIdentifier | ts.StringLiteral | ts.QualifiedName | ts.NumericLiteral | ts.ComputedPropertyName | ts.BindingName | undefined): string | undefined;
-export declare const defaultCompilerOptions: ts.CompilerOptions;
-export declare function serializerBaseMethods(): string[];
-export declare function getNameWithoutQualifiersRight(node: ts.EntityName | undefined): string | undefined;
-export declare function getNameWithoutQualifiersLeft(node: ts.EntityName | undefined): string | undefined;
 export declare function snakeCaseToCamelCase(input: string, tailToLowerCase?: boolean): string;
 export declare function toCamelCase(input: string): string;
 export declare function isUpperCase(s: string): boolean;
@@ -61,9 +24,7 @@ export declare function renameDtsToComponent(fileName: string, language: Languag
 export declare function renameDtsToInterfaces(fileName: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameClassToBuilderClass(className: string, language: Language, withFileExtension?: boolean): string;
 export declare function renameClassToMaterialized(className: string, language: Language, withFileExtension?: boolean): string;
-export declare function importTypeName(type: ts.ImportTypeNode, asType?: boolean): string;
 export declare function throwException(message: string): never;
-export declare function className(node: ts.ClassDeclaration | ts.InterfaceDeclaration): string;
 /**
  * Add a prefix to an enum value which camel case name coincidence
  * with the the same upper case name for an another enum value
@@ -100,5 +61,10 @@ export declare function getTransformer(library: LibraryInterface, from: idl.IDLN
     receiver?: string;
     method: string;
 };
+export declare function removePoints(s: string): string;
+export declare function scanDirectory(dir: string, fileFilter: (file: string) => boolean, recursive?: boolean): string[];
+export declare function scanInputDirs(inputDirs: string[]): string[];
+export declare function scanInputDirs(inputDirs: string[], fileExtension: string): string[];
+export declare function scanInputDirs(inputDirs: string[], fileFilter: (file: string) => boolean, recursive: boolean): string[];
 export {};
 //# sourceMappingURL=util.d.ts.map