@idlizer/core 2.1.10-arktscgen-3a → 2.1.10-arktscgen-5

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

@@ -3,7 +3,6 @@ export declare class Language {
     extension: string;
     static TS: Language;
     static ARKTS: Language;
-    static JAVA: Language;
     static CPP: Language;
     static CJ: Language;
     static KOTLIN: Language;

package/build/lib/src/Language.js

@@ -26,7 +26,6 @@ export class Language {
     static fromString(name) {
         switch (name) {
             case "arkts": return Language.ARKTS;
-            case "java": return Language.JAVA;
             case "ts": return Language.TS;
             case "cangjie": return Language.CJ;
             case "cpp": return Language.CPP;
@@ -37,7 +36,6 @@ export class Language {
 }
 Language.TS = new Language("TS", ".ts");
 Language.ARKTS = new Language("ArkTS", ".ts"); // using .ts for ArkTS until we get rit of tsc preprocessing
-Language.JAVA = new Language("Java", ".java");
 Language.CPP = new Language("C++", ".cc");
 Language.CJ = new Language("CangJie", ".cj");
 Language.KOTLIN = new Language("Kotlin", ".kt");

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

@@ -6,7 +6,7 @@ import { LibraryInterface } from "../LibraryInterface";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PeerLibrary } from "../peer-generation/PeerLibrary";
 import { PeerMethodSignature } from "../peer-generation/PeerMethod";
-export declare function getSerializerName(declaration: idl.IDLEntry): string;
+export declare function getSerializerName(library: LibraryInterface, language: Language, declaration: idl.IDLEntry): string;
 export interface ArgConvertor {
     param: string;
     idlType: idl.IDLType;
@@ -106,8 +106,9 @@ export declare class NumberConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class NumericConvertor extends BaseArgConvertor {
+    protected library: LibraryInterface;
     private readonly interopNameConvertor;
-    constructor(param: string, type: idl.IDLPrimitiveType);
+    constructor(library: LibraryInterface, param: string, type: idl.IDLPrimitiveType);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, writer: LanguageWriter): LanguageStatement;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
@@ -343,5 +344,17 @@ export declare function generateCallbackKindAccess(callback: idl.IDLCallback, la
 export declare function generateCallbackKindValue(callback: idl.IDLCallback): number;
 export declare function generateCallbackAPIArguments(library: LibraryInterface, callback: idl.IDLCallback): string[];
 export declare function maybeTransformManagedCallback(callback: idl.IDLCallback, library: ReferenceResolver): idl.IDLCallback | undefined;
+export declare class TransformOnSerializeConvertor extends BaseArgConvertor {
+    protected library: PeerLibrary;
+    protected managedDeclaration: idl.IDLEntry;
+    protected target: idl.IDLType;
+    private targetConvertor;
+    constructor(param: string, library: PeerLibrary, managedDeclaration: idl.IDLEntry, target: idl.IDLType);
+    isPointerType(): boolean;
+    nativeType(): idl.IDLType;
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, writer: LanguageWriter): LanguageStatement;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+}
 export declare function createOutArgConvertor(library: PeerLibrary, type: idl.IDLType | undefined, otherParams: string[]): ArgConvertor | undefined;
 //# sourceMappingURL=ArgConvertors.d.ts.map

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

@@ -17,17 +17,18 @@ import { Language } from "../Language";
 import { BlockStatement, PrintHint, StringExpression, MethodModifier, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorConfiguration, generatorTypePrefix } from "../config";
-import { capitalize, getExtractor, hashCodeFromString, throwException, warn } from "../util";
+import { capitalize, getExtractor, getTransformer, hashCodeFromString, throwException, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
-import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
-import { qualifiedName } from "../peer-generation/idl/common";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
 import { PeerMethodSignature } from "../peer-generation/PeerMethod";
 import { isInExternalModule } from "../peer-generation/modules";
-export function getSerializerName(declaration) {
-    return `${idl.getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
+import { isTopLevelConflicted } from "../peer-generation/ConflictingDeclarations";
+export function getSerializerName(library, language, declaration) {
+    const qualifier = isTopLevelConflicted(library, language, declaration)
+        ? "package.namespace.name" : "namespace.name";
+    return `${idl.getQualifiedName(declaration, qualifier).split('.').join('_')}_serializer`;
 }
 export function isDirectConvertedType(originalType, library) {
     const debug = false;
@@ -298,10 +299,11 @@ export class NumberConvertor extends BaseArgConvertor {
     }
 }
 export class NumericConvertor extends BaseArgConvertor {
-    constructor(param, type) {
+    constructor(library, param, type) {
         // check numericPrimitiveTypes.include(type)
         super(type, [RuntimeType.NUMBER], false, false, param);
-        this.interopNameConvertor = new CppNameConvertor(createEmptyReferenceResolver());
+        this.library = library;
+        this.interopNameConvertor = new CppNameConvertor(this.library);
     }
     convertorArg(param, writer) {
         return param;
@@ -577,12 +579,12 @@ export class InterfaceConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, writer) {
-        const accessor = getSerializerName(this.declaration);
+        const accessor = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
-        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(value)]));
+        return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(writer.escapeKeyword(value))]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessor = getSerializerName(this.declaration);
+        const accessor = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return assigneer(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]));
     }
@@ -888,7 +890,7 @@ export class OptionConvertor extends BaseArgConvertor {
         const bufferType = this.nativeType();
         statements.push(writer.makeAssign(bufferName, bufferType, writer.language === Language.CPP ? undefined : writer.makeNull(this.type), true, false)); // maybe change to generic None
         const thenStatement = new BlockStatement([
-            this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
+            this.typeConvertor.convertorDeserialize(`${bufferName}Opt`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
                     ? `${bufferName}.value` : bufferName;
                 return writer.makeAssign(receiver, undefined, expr, false);
@@ -1018,11 +1020,10 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
+        const nameConvertor = this.library.createTypeNameConvertor(Language.CPP);
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
-            case Language.JAVA:
-            case Language.KOTLIN:
+                return `static_cast<${nameConvertor.convert(this.declaration)}>(${param})`;
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
@@ -1034,12 +1035,12 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         }
     }
     convertorSerialize(param, value, printer) {
-        const accessorRoot = getSerializerName(this.declaration);
+        const accessorRoot = getSerializerName(this.library, printer.language, this.declaration);
         printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return printer.makeStatement(printer.makeStaticMethodCall(accessorRoot, 'write', [printer.makeString(`${param}Serializer`), printer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessorRoot = getSerializerName(this.declaration);
+        const accessorRoot = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessorRoot, "read", [writer.makeString(deserializerName)]), this.declaration);
         return assigneer(readStatement);
@@ -1116,8 +1117,10 @@ export class CallbackConvertor extends BaseArgConvertor {
                 writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writePointer", [writer.makeCast(new StringExpression(`${value}.callSync`), idl.IDLPointerType, { unsafe: true })]))
             ], false);
         }
-        if (this.isTransformed)
-            value = `CallbackTransformer.transformFrom${this.library.getInteropName(this.decl)}(${value})`;
+        if (this.isTransformed) {
+            const convertor = this.library.createTypeNameConvertor(Language.CPP);
+            value = `CallbackTransformer.transformFrom${convertor.convert(this.decl)}(${value})`;
+        }
         return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallback`, [writer.makeString(`${value}`)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer, useSyncVersion = true) {
@@ -1222,7 +1225,7 @@ function warnCustomObject(type, msg) {
 }
 export const CallbackKind = "CallbackKind";
 export function generateCallbackKindName(callback) {
-    return `Kind_${callback.name}`;
+    return `KIND_${callback.name.toUpperCase()}`;
 }
 export function generateCallbackKindAccess(callback, language) {
     const name = generateCallbackKindName(callback);
@@ -1295,6 +1298,59 @@ class PromiseOutArgConvertor extends BaseArgConvertor {
         return true;
     }
 }
+export class TransformOnSerializeConvertor extends BaseArgConvertor {
+    constructor(param, library, managedDeclaration, target) {
+        const targetConvertor = library.typeConvertor(param, target);
+        super(target, targetConvertor.runtimeTypes, false, targetConvertor.useArray, param);
+        this.library = library;
+        this.managedDeclaration = managedDeclaration;
+        this.target = target;
+        this.targetConvertor = targetConvertor;
+    }
+    isPointerType() {
+        return this.targetConvertor.isPointerType();
+    }
+    nativeType() {
+        return this.targetConvertor.nativeType();
+    }
+    convertorArg(param, writer) {
+        throw new Error("Method not implemented.");
+    }
+    convertorSerialize(param, value, writer) {
+        if (writer.language === Language.CPP) {
+            return this.targetConvertor.convertorSerialize(param, value, writer);
+        }
+        if (idl.isReferenceType(this.target)) {
+            writer.addFeature(this.target);
+        }
+        const transformerInfo = getTransformer(this.library, this.managedDeclaration, this.target);
+        const transformCallExpression = transformerInfo.receiver
+            ? writer.makeMethodCall(transformerInfo.receiver, transformerInfo.method, [writer.makeString(value)])
+            : writer.makeFunctionCall(transformerInfo.method, [writer.makeString(value)]);
+        const statements = [
+            writer.makeAssign(`${value}Transformed`, this.target, transformCallExpression, true),
+            this.targetConvertor.convertorSerialize(param, `${value}Transformed`, writer)
+        ];
+        return writer.makeBlock(statements, false);
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        if (writer.language === Language.CPP) {
+            return this.targetConvertor.convertorDeserialize(bufferName, deserializerName, assigneer, writer);
+        }
+        if (idl.isReferenceType(this.target)) {
+            writer.addFeature(this.target);
+        }
+        const targetDeserialize = this.targetConvertor.convertorDeserialize(`${bufferName}D`, deserializerName, (expr) => writer.makeAssign(`${bufferName}Deserialized`, this.target, expr, true), writer);
+        const transformerInfo = getTransformer(this.library, this.target, this.managedDeclaration);
+        const transformCallExpression = transformerInfo.receiver
+            ? writer.makeMethodCall(transformerInfo.receiver, transformerInfo.method, [writer.makeString(`${bufferName}Deserialized`)])
+            : writer.makeFunctionCall(transformerInfo.method, [writer.makeString(`${bufferName}Deserialized`)]);
+        return writer.makeBlock([
+            targetDeserialize,
+            assigneer(transformCallExpression)
+        ], false);
+    }
+}
 export function createOutArgConvertor(library, type, otherParams) {
     if (type && idl.isContainerType(type) && idl.IDLContainerUtils.isPromise(type)) {
         const param = (entropy) => `outputArgumentForReturningPromise${entropy || ''}`;

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

@@ -146,7 +146,9 @@ export declare enum FieldModifier {
     FINAL = 5,
     VOLATILE = 6,
     INTERNAL = 7,
-    OVERRIDE = 8
+    OVERRIDE = 8,
+    GET = 9,
+    SET = 10
 }
 export declare enum MethodModifier {
     PUBLIC = 0,
@@ -244,8 +246,17 @@ export declare abstract class LanguageWriter {
     language: Language);
     indentDepth(): number;
     maybeSemicolon(): string;
-    features: [string, string][];
+    features: ({
+        type: "raw";
+        feature: string;
+        module: string;
+    } | {
+        type: "idl";
+        node: idl.IDLEntry | idl.IDLReferenceType;
+    })[];
+    addFeature(node: idl.IDLEntry | idl.IDLReferenceType): void;
     addFeature(feature: string, module: string): void;
+    abstract get interopModule(): string;
     abstract writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
     abstract writeEnum(name: string, members: {
         name: string;
@@ -272,6 +283,7 @@ export declare abstract class LanguageWriter {
     }, initExpr?: LanguageExpression): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
+    abstract writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     abstract makeThrowError(message: string): LanguageStatement;

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

@@ -278,8 +278,11 @@ export class LambdaExpression {
         if (this.body) {
             writer.writeStatement(new BlockStatement(this.body, isScoped, false));
         }
-        writer.features.forEach(([feature, module]) => {
-            this.originalWriter.addFeature(feature, module);
+        writer.features.forEach((feature) => {
+            if (feature.type === "raw")
+                this.originalWriter.addFeature(feature.feature, feature.module);
+            else
+                this.originalWriter.addFeature(feature.node);
         });
         return writer.getOutput()
             .map(line => (line.endsWith('{') || line.endsWith('}') || line.endsWith(';')) ? line : `${line};`)
@@ -304,6 +307,8 @@ export var FieldModifier;
     FieldModifier[FieldModifier["VOLATILE"] = 6] = "VOLATILE";
     FieldModifier[FieldModifier["INTERNAL"] = 7] = "INTERNAL";
     FieldModifier[FieldModifier["OVERRIDE"] = 8] = "OVERRIDE";
+    FieldModifier[FieldModifier["GET"] = 9] = "GET";
+    FieldModifier[FieldModifier["SET"] = 10] = "SET";
 })(FieldModifier || (FieldModifier = {}));
 export var MethodModifier;
 (function (MethodModifier) {
@@ -421,8 +426,11 @@ export class LanguageWriter {
         return this.printer.indentDepth();
     }
     maybeSemicolon() { return ";"; }
-    addFeature(feature, module) {
-        this.features.push([feature, module]);
+    addFeature(featureOrNode, module) {
+        if (typeof featureOrNode === "string")
+            this.features.push({ type: "raw", feature: featureOrNode, module: module });
+        else
+            this.features.push({ type: "idl", node: featureOrNode });
     }
     // version of makeCast which uses TypeCheck.typeCast<T>(value) call for ETS language writer
     // Use it only if TypeChecker class is added as import to the generated file

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

@@ -32,5 +32,4 @@ export declare class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvert
 export declare class CJInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
-export declare function removePoints(s: string): string;
 //# sourceMappingURL=CJConvertors.d.ts.map

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

@@ -15,6 +15,7 @@
 import * as idl from '../../idl';
 import { CJKeywords } from '../../languageSpecificKeywords';
 import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
+import { removePoints } from '../../util';
 import { convertNode, convertType } from '../nameConvertor';
 import { InteropArgConvertor } from './InteropConvertors';
 export class CJTypeNameConvertor {
@@ -149,7 +150,7 @@ export class CJTypeNameConvertor {
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
     callbackType(decl) {
-        const params = decl.parameters.map(it => `${CJKeywords.has(it.name) ? it.name.concat("_") : it.name}: ${this.convert(it.type)}`);
+        const params = decl.parameters.map(it => `${CJKeywords.has(it.name) ? it.name.concat("_") : it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
@@ -199,7 +200,4 @@ export class CJInteropArgConvertor extends InteropArgConvertor {
         return super.convertPrimitiveType(type);
     }
 }
-export function removePoints(s) {
-    return s.split(/[\.\-]/g).join('_');
-}
 //# sourceMappingURL=CJConvertors.js.map

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

@@ -1,15 +1,15 @@
 import * as idl from '../../idl';
 import { IdlNameConvertor, NodeConvertor, TypeConvertor } from "../nameConvertor";
 import { InteropArgConvertor } from './InteropConvertors';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { LibraryInterface } from '../../LibraryInterface';
 export interface ConvertResult {
     text: string;
     noPrefix: boolean;
     resolvedType: idl.IDLType;
 }
 export declare class GenericCppConvertor implements NodeConvertor<ConvertResult> {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
+    protected library: LibraryInterface;
+    constructor(library: LibraryInterface);
     private make;
     convertNode(node: idl.IDLNode): ConvertResult;
     convertNamespace(node: idl.IDLNamespace): ConvertResult;
@@ -36,9 +36,9 @@ export declare class CppConvertor extends GenericCppConvertor implements IdlName
     convert(node: idl.IDLNode): string;
 }
 export declare class CppNameConvertor implements IdlNameConvertor {
-    protected resolver: ReferenceResolver;
+    protected library: LibraryInterface;
     private readonly cppConvertor;
-    constructor(resolver: ReferenceResolver);
+    constructor(library: LibraryInterface);
     convert(node: idl.IDLNode): string;
 }
 export declare class CppInteropArgConvertor extends InteropArgConvertor {
@@ -47,9 +47,9 @@ export declare class CppInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
 export declare class CppReturnTypeConvertor implements TypeConvertor<string> {
-    private resolver;
+    private library;
     private convertor;
-    constructor(resolver: ReferenceResolver);
+    constructor(library: LibraryInterface);
     isVoid(returnType: idl.IDLType): boolean;
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;

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

@@ -13,18 +13,30 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
-import { generatorConfiguration, generatorTypePrefix } from "../../config";
+import { generatorConfiguration } from "../../config";
 import { convertNode, convertType } from "../nameConvertor";
 import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
 import { InteropArgConvertor } from './InteropConvertors';
 import { maybeTransformManagedCallback } from '../ArgConvertors';
 import { qualifiedName } from '../../peer-generation/idl/common';
-import { capitalize } from '../../util';
-import { isMaterialized } from '../../peer-generation/isMaterialized';
-import { isInIdlizeInternal } from '../../idlize';
+import { isInIdlizeInternal } from '../../idl';
+import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
+import { Language } from '../../Language';
+function isSubtypeTopLevelConflicted(library, node) {
+    let hasConflicts = false;
+    idl.forEachChild(node, (child) => {
+        if (idl.isReferenceType(child)) {
+            const decl = library.resolveTypeReference(child);
+            if (decl) {
+                hasConflicts || (hasConflicts = isTopLevelConflicted(library, Language.CPP, decl));
+            }
+        }
+    });
+    return hasConflicts;
+}
 export class GenericCppConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
+    constructor(library) {
+        this.library = library;
     }
     make(text, resolvedType, noPrefix = false) {
         return { text, noPrefix, resolvedType };
@@ -78,6 +90,12 @@ export class GenericCppConvertor {
         return this.make(prefix + converted.text, type, true);
     }
     convertUnion(type) {
+        if (isSubtypeTopLevelConflicted(this.library, type)) {
+            if (type.parent && idl.isTypedef(type.parent)) {
+                return this.make(type.parent.name, type, false);
+            }
+            return this.make('Union_' + type.types.map(it => convertType(this, it).text).join("_"), type, false);
+        }
         return this.make(type.name, type, false);
     }
     convertContainer(type) {
@@ -108,14 +126,11 @@ export class GenericCppConvertor {
         if (generatorConfiguration().parameterized.includes(refName)) {
             return this.make('CustomObject', idl.IDLCustomObjectType);
         }
-        let decl = this.resolver.toDeclaration(type);
+        let decl = this.library.toDeclaration(type);
         if (idl.isCallback(decl)) {
-            decl = (_a = maybeTransformManagedCallback(decl, this.resolver)) !== null && _a !== void 0 ? _a : decl;
+            decl = (_a = maybeTransformManagedCallback(decl, this.library)) !== null && _a !== void 0 ? _a : decl;
         }
         if (idl.isType(decl)) {
-            if (idl.isReferenceType(decl)) {
-                return this.make(`${capitalize(decl.name)}`, decl);
-            }
             return this.convertNode(decl);
         }
         let res = this.convertNode(decl);
@@ -159,6 +174,9 @@ export class GenericCppConvertor {
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }
     qualifiedName(target) {
+        if (idl.isEntry(target) && isTopLevelConflicted(this.library, Language.CPP, target)) {
+            return qualifiedName(target, "_", "package.namespace.name");
+        }
         return qualifiedName(target, "_", "namespace.name");
     }
     computeTargetTypeLiteralName(decl) {
@@ -188,10 +206,10 @@ export class CppConvertor extends GenericCppConvertor {
     isPrimitiveOrPrimitiveAlias(type) {
         if (!idl.isType(type))
             return false;
-        const { resolver } = this;
+        const { library } = this;
         const seen = new Set;
         while (type && idl.isReferenceType(type)) {
-            const resolved = resolver.resolveTypeReference(type);
+            const resolved = library.resolveTypeReference(type);
             if (!resolved)
                 return false;
             if (!idl.isTypedef(resolved))
@@ -208,9 +226,9 @@ export class CppConvertor extends GenericCppConvertor {
     }
 }
 export class CppNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.cppConvertor = new GenericCppConvertor(resolver);
+    constructor(library) {
+        this.library = library;
+        this.cppConvertor = new GenericCppConvertor(library);
     }
     convert(node) {
         return this.cppConvertor.convertNode(node).text;
@@ -236,9 +254,9 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
 }
 CppInteropArgConvertor.INSTANCE = new CppInteropArgConvertor();
 export class CppReturnTypeConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
-        this.convertor = new CppConvertor(resolver);
+    constructor(library) {
+        this.library = library;
+        this.convertor = new CppConvertor(library);
     }
     isVoid(returnType) {
         return this.convert(returnType) == 'void';
@@ -271,10 +289,6 @@ export class CppReturnTypeConvertor {
         return this.convertor.convert(type);
     }
     convertTypeReference(type) {
-        const decl = this.resolver.resolveTypeReference(type);
-        if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
-            return generatorTypePrefix() + qualifiedName(decl, "_", "namespace.name");
-        }
         return this.convertor.convert(type);
     }
     convertUnion(type) {

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

@@ -16,7 +16,7 @@ import * as idl from '../../idl';
 import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
 import { isMaterialized } from '../../peer-generation/isMaterialized';
 import { convertNode, convertType } from '../nameConvertor';
-import { removePoints } from './CJConvertors';
+import { removePoints } from '../../util';
 import { InteropReturnTypeConvertor } from './InteropConvertors';
 export class KotlinTypeNameConvertor {
     constructor(resolver) {
@@ -55,6 +55,11 @@ export class KotlinTypeNameConvertor {
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
+            switch (type.elementType[0]) {
+                case idl.IDLU8Type: return "UByteArray";
+                case idl.IDLI32Type: return "IntArray";
+                case idl.IDLF32Type: return "FloatArray";
+            }
             return `ArrayList<${convertType(this, type.elementType[0])}>`;
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
@@ -93,7 +98,7 @@ export class KotlinTypeNameConvertor {
             case idl.IDLUnknownType:
             case idl.IDLCustomObjectType: return 'Any';
             case idl.IDLThisType: return 'this';
-            case idl.IDLObjectType: return 'Object';
+            case idl.IDLObjectType: return 'Any';
             case idl.IDLAnyType: return 'Any';
             case idl.IDLUndefinedType: return 'Nothing?';
             case idl.IDLPointerType: return 'KPointer';
@@ -135,7 +140,6 @@ const KLong = "KLong";
 const KFloat = "KFloat";
 const KDouble = "KDouble";
 const KNativePointer = "KNativePointer";
-const KInteropNumber = "KInteropNumber";
 const KStringPtr = "KStringPtr";
 const KInteropReturnBuffer = "KInteropReturnBuffer";
 const KInteropBuffer = "KInteropBuffer";
@@ -154,7 +158,7 @@ export class KotlinCInteropReturnTypeConvertor extends InteropReturnTypeConverto
             case idl.IDLF16Type:
             case idl.IDLF32Type:
             case idl.IDLF64Type: return KInt;
-            case idl.IDLNumberType: return KInteropNumber;
+            case idl.IDLNumberType: return KDouble;
             case idl.IDLBooleanType: return KBoolean;
             case idl.IDLBigintType: return KLong;
             case idl.IDLAnyType:
@@ -218,7 +222,7 @@ export class KotlinCInteropArgConvertor {
             case idl.IDLU32Type: return KInt;
             case idl.IDLF32Type: return KFloat;
             case idl.IDLF64Type: return KDouble;
-            case idl.IDLNumberType: return KInteropNumber;
+            case idl.IDLNumberType: return KDouble;
             case idl.IDLBigintType: return KLong;
             case idl.IDLSerializerBuffer: return KSerializerBuffer;
             case idl.IDLBooleanType:

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

@@ -1,9 +1,10 @@
 import * as idl from '../../idl';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { LibraryInterface } from '../../LibraryInterface';
 import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
 export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
+    protected library: LibraryInterface;
+    constructor(library: LibraryInterface);
+    protected mangleTopLevel(decl: idl.IDLEntry): string | undefined;
     convert(node: idl.IDLNode): string;
     convertNamespace(node: idl.IDLNamespace): string;
     convertInterface(node: idl.IDLInterface): string;
@@ -22,7 +23,6 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
     protected createTypeSubstitution(parameters: string[] | undefined, args: idl.IDLType[] | undefined): Map<string, idl.IDLType>;
-    protected applySubstitution(subst: Map<string, idl.IDLType>, type: idl.IDLType): idl.IDLType;
     protected mapCallback(decl: idl.IDLCallback, args?: idl.IDLType[]): string;
     protected productType(decl: idl.IDLInterface, args: idl.IDLType[] | undefined, isTuple: boolean, includeFieldNames: boolean): string;
     protected mapFunctionType(typeArgs: string[]): string;