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

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

@@ -13,18 +13,31 @@
  * 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;
+        this.isInsideStructure = false;
     }
     make(text, resolvedType, noPrefix = false) {
         return { text, noPrefix, resolvedType };
@@ -78,22 +91,29 @@ export class GenericCppConvertor {
         return this.make(prefix + converted.text, type, true);
     }
     convertUnion(type) {
-        return this.make(type.name, type, false);
+        return this.insideStructure(() => {
+            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);
+        });
     }
     convertContainer(type) {
-        if (idl.IDLContainerUtils.isPromise(type)) {
-            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`, type);
-        }
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            if (type.elementType[0] === idl.IDLU8Type) {
-                return this.make(`uint8_t*`, type, true);
+        return this.insideStructure(() => {
+            if (idl.IDLContainerUtils.isPromise(type)) {
+                return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`, type);
             }
-            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, type, true);
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, type, true);
-        }
-        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+            if (idl.IDLContainerUtils.isSequence(type)) {
+                if (type.elementType[0] === idl.IDLU8Type) {
+                    return this.make(`uint8_t*`, type, true);
+                }
+                return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, type, true);
+            }
+            if (idl.IDLContainerUtils.isRecord(type)) {
+                return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, type, true);
+            }
+            throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+        });
     }
     convertImport(type) {
         console.warn("Imports are not implemented yet");
@@ -108,14 +128,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);
@@ -127,6 +144,26 @@ export class GenericCppConvertor {
         return this.make('CustomObject', idl.IDLCustomObjectType);
     }
     convertPrimitiveType(type) {
+        if (this.isInsideStructure) {
+            switch (type) {
+                case idl.IDLVoidType:
+                    return this.make(`Void`, type);
+                case idl.IDLI32Type:
+                    return this.make('I32', type);
+                case idl.IDLU32Type:
+                    return this.make('U32', type);
+                case idl.IDLF32Type:
+                    return this.make('F32', type);
+                case idl.IDLI64Type:
+                    return this.make('I64', type);
+                case idl.IDLU64Type:
+                    return this.make('U64', type);
+                case idl.IDLF64Type:
+                    return this.make('F64', type);
+                case idl.IDLPointerType:
+                    return this.make('Pointer', type);
+            }
+        }
         switch (type) {
             case idl.IDLThisType: // maybe fix it in another level?
             case idl.IDLVoidType: return this.make('void', type, true);
@@ -159,6 +196,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) {
@@ -172,6 +212,13 @@ export class GenericCppConvertor {
         const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
         return `Literal_${names.join('_')}`;
     }
+    insideStructure(cb) {
+        const prevIsInsideScructure = this.isInsideStructure;
+        this.isInsideStructure = true;
+        const result = cb();
+        this.isInsideStructure = prevIsInsideScructure;
+        return result;
+    }
 }
 export class CppConvertor extends GenericCppConvertor {
     unwrap(type, result) {
@@ -188,10 +235,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,14 +255,23 @@ 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;
     }
 }
+export class StructureNameConvertor extends CppConvertor {
+    constructor(library) {
+        super(library);
+        this.isInsideStructure = true;
+    }
+    convert(node) {
+        return this.convertNode(node).text;
+    }
+}
 export class CppInteropArgConvertor extends InteropArgConvertor {
     convertOptional(type) {
         return PrimitiveTypesInstance.NativePointer.getText();
@@ -236,9 +292,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 +327,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/ETSConvertors.d.ts

@@ -10,5 +10,6 @@ export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     protected mapFunctionType(typeArgs: string[]): string;
 }
 export declare class ETSInteropArgConvertor extends TSInteropArgConvertor {
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
 //# sourceMappingURL=ETSConvertors.d.ts.map

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

@@ -14,6 +14,7 @@
  */
 import * as idl from "../../idl";
 import { LanguageWriter } from "../LanguageWriter";
+import { isInsideInstanceof } from "../nameConvertor";
 import { TSInteropArgConvertor, TSTypeNameConvertor } from "./TSConvertors";
 export class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type) {
@@ -25,18 +26,13 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         }
         // TODO: Fix for 'TypeError: Type 'Function<R>' is generic but type argument were not provided.'
         if (typeName === "Function") {
-            return "Function<void>";
+            return isInsideInstanceof() ? "Function" : "Function<void>";
         }
         return typeName;
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
-            switch (type.elementType[0]) {
-                case idl.IDLU8Type: return 'KUint8ArrayPtr';
-                case idl.IDLI32Type: return 'KInt32ArrayPtr';
-                case idl.IDLF32Type: return 'KFloat32ArrayPtr';
-            }
-            return `Array<${this.convert(type.elementType[0])}>`;
+            return isInsideInstanceof() ? `Array` : `Array<${this.convert(type.elementType[0])}>`;
         }
         return super.convertContainer(type);
     }
@@ -95,9 +91,15 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         if (typeArgs.length === 0) {
             typeArgs = [this.convert(idl.IDLVoidType)];
         }
-        return `Function${typeArgs.length - 1}<${typeArgs.join(",")}>`;
+        return isInsideInstanceof() ? `Function${typeArgs.length - 1}` : `Function${typeArgs.length - 1}<${typeArgs.join(",")}>`;
     }
 }
 export class ETSInteropArgConvertor extends TSInteropArgConvertor {
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLBigintType: return 'long';
+        }
+        return super.convertPrimitiveType(type);
+    }
 }
 //# sourceMappingURL=ETSConvertors.js.map

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

@@ -84,7 +84,7 @@ export class InteropReturnTypeConvertor {
         if (decl) {
             // Callbacks and array types return by value
             if (idl.isCallback(this.resolver.toDeclaration(type))) {
-                return type.name;
+                return KInteropReturnBuffer;
             }
             if (idl.isInterface(decl)) {
                 if (isMaterialized(decl, this.resolver)) {

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;

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

@@ -13,11 +13,26 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { Language } from '../../Language';
+import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
+import { isDeclaredInCurrentFile, LayoutNodeRole } from '../../peer-generation/LayoutManager';
 import { maybeRestoreGenerics } from '../../transformers/GenericTransformer';
-import { convertNode, convertType } from '../nameConvertor';
+import { convertNode, convertType, isInsideInstanceof } from '../nameConvertor';
 export class TSTypeNameConvertor {
-    constructor(resolver) {
-        this.resolver = resolver;
+    constructor(library) {
+        this.library = library;
+    }
+    mangleTopLevel(decl) {
+        if (!isDeclaredInCurrentFile(this.library.layout, { node: decl, role: LayoutNodeRole.INTERFACE }) && isTopLevelConflicted(this.library, Language.TS, decl)) {
+            const namespaces = idl.getNamespacesPathFor(decl);
+            if (namespaces.length === 0) {
+                return idl.getQualifiedName(decl, "package.namespace.name").replaceAll('.', '_');
+            }
+            const [rootNamespace, ...otherNamespaces] = idl.getNamespacesPathFor(decl);
+            const mangledRoot = idl.getQualifiedName(rootNamespace, "package.namespace.name").replaceAll('.', '_');
+            return [mangledRoot, ...otherNamespaces, decl.name].join(".");
+        }
+        return undefined;
     }
     convert(node) {
         return convertNode(this, node);
@@ -26,18 +41,24 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return idl.getQualifiedName(node, "namespace.name");
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertEnum(node) {
-        return idl.getQualifiedName(node, "namespace.name");
+        var _a;
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertTypedef(node) {
-        return node.name;
+        var _a;
+        if (idl.isSyntheticEntry(node))
+            return this.convert(node.type);
+        return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertCallback(node) {
+        var _a;
         return idl.isSyntheticEntry(node)
             ? this.mapCallback(node)
-            : node.name;
+            : (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : node.name;
     }
     convertMethod(node) {
         return node.name;
@@ -68,18 +89,13 @@ export class TSTypeNameConvertor {
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
-            switch (type.elementType[0]) {
-                case idl.IDLU8Type: return 'Uint8Array'; // should be changed to Array
-                case idl.IDLI32Type: return 'Int32Array'; // should be changed to Array
-                case idl.IDLF32Type: return 'KFloat32ArrayPtr'; // should be changed to Array
-                default: return `Array<${this.convert(type.elementType[0])}>`;
-            }
+            return isInsideInstanceof() ? `Array` : `Array<${this.convert(type.elementType[0])}>`;
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
-            return `Map<${this.convert(type.elementType[0])}, ${this.convert(type.elementType[1])}>`;
+            return isInsideInstanceof() ? `Map` : `Map<${this.convert(type.elementType[0])}, ${this.convert(type.elementType[1])}>`;
         }
         if (idl.IDLContainerUtils.isPromise(type)) {
-            return `Promise<${this.convert(type.elementType[0])}>`;
+            return isInsideInstanceof() ? `Promise` : `Promise<${this.convert(type.elementType[0])}>`;
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -89,20 +105,23 @@ export class TSTypeNameConvertor {
     }
     convertTypeReferenceAsImport(type, importClause) {
         var _a;
-        const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) ? `<${type.typeArguments.join(', ')}>` : "";
-        let decl = this.resolver.resolveTypeReference(type);
+        const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) && !isInsideInstanceof() ? `<${type.typeArguments.join(', ')}>` : "";
+        let decl = this.library.resolveTypeReference(type);
         if (decl)
             return `${decl.name}${maybeTypeArguments}`;
         return `${type.name}${maybeTypeArguments}`;
     }
     convertTypeReference(type) {
-        var _a, _b;
-        let decl = this.resolver.resolveTypeReference(type);
+        var _a, _b, _c;
+        let decl = this.library.resolveTypeReference(type);
         if (decl) {
             if (idl.isSyntheticEntry(decl)) {
                 if (idl.isCallback(decl)) {
                     return this.mapCallback(decl, type.typeArguments);
                 }
+                if (idl.isTypedef(decl)) {
+                    return this.convert(decl.type);
+                }
                 const entity = idl.getExtAttribute(decl, idl.IDLExtendedAttributes.Entity);
                 if (entity) {
                     const isTuple = entity === idl.IDLEntity.Tuple;
@@ -116,13 +135,15 @@ export class TSTypeNameConvertor {
                 // (can not cast MyEnum to exact MyEnum.Value1)
                 decl = decl.parent;
             }
-            let maybeRestoredGeneric = maybeRestoreGenerics(type, this.resolver);
+            let maybeRestoredGeneric = maybeRestoreGenerics(type, this.library);
             if (maybeRestoredGeneric) {
                 type = maybeRestoredGeneric;
-                decl = this.resolver.resolveTypeReference(maybeRestoredGeneric);
+                decl = this.library.resolveTypeReference(maybeRestoredGeneric);
             }
             let typeSpec = type.name;
-            let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : [];
+            let typeArgs = !isInsideInstanceof() || decl && idl.isCallback(decl)
+                ? (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : []
+                : [];
             if (typeSpec === `Optional`)
                 return `${typeArgs} | undefined`;
             if (typeSpec === `Function`)
@@ -131,7 +152,7 @@ export class TSTypeNameConvertor {
             if (decl) {
                 const path = idl.getNamespacesPathFor(decl).map(it => it.name);
                 path.push(decl.name);
-                return `${path.join(".")}${maybeTypeArguments}`;
+                return `${(_c = this.mangleTopLevel(decl)) !== null && _c !== void 0 ? _c : path.join(".")}${maybeTypeArguments}`;
             }
             return `${type.name}${maybeTypeArguments}`;
         }
@@ -192,27 +213,16 @@ export class TSTypeNameConvertor {
         }
         return subst;
     }
-    applySubstitution(subst, type) {
-        var _a;
-        if (idl.isContainerType(type)) {
-            return idl.createContainerType(type.containerKind, type.elementType.map(it => this.applySubstitution(subst, it)));
-        }
-        if (idl.isReferenceType(type)) {
-            return idl.createReferenceType(type.name, (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.applySubstitution(subst, it)));
-        }
-        if (idl.isTypeParameterType(type)) {
-            const record = subst.get(type.name);
-            if (record) {
-                return record;
-            }
-        }
-        return type;
-    }
     mapCallback(decl, args) {
         const subst = this.createTypeSubstitution(decl.typeParameters, args);
         const parameters = decl.parameters.map(it => {
+            if (subst.size == 0)
+                return it;
             const param = idl.clone(it);
-            param.type = this.applySubstitution(subst, param.type);
+            param.parent = it.parent;
+            const type = applySubstitution(subst, param.type);
+            updateParent(param, type);
+            param.type = type;
             return param;
         });
         const params = parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}${it.isVariadic ? "[]" : ""}`);
@@ -223,8 +233,13 @@ export class TSTypeNameConvertor {
         const name = `${isTuple ? "[" : "{"} ${decl.properties
             .map(it => isTuple ? this.processTupleType(it) : it)
             .map(it => {
+            if (subst.size == 0)
+                return it;
             const prop = idl.clone(it);
-            prop.type = this.applySubstitution(subst, prop.type);
+            prop.parent = it.parent;
+            const type = applySubstitution(subst, prop.type);
+            updateParent(prop, type);
+            prop.type = type;
             return prop;
         })
             .map(it => {
@@ -236,7 +251,7 @@ export class TSTypeNameConvertor {
         return name;
     }
     mapFunctionType(typeArgs) {
-        return `Function${typeArgs.length ? `<${typeArgs.join(",")}>` : ''}`;
+        return isInsideInstanceof() ? `Function` : `Function${typeArgs.length ? `<${typeArgs.join(",")}>` : ''}`;
     }
 }
 export class TSInteropArgConvertor {
@@ -244,6 +259,11 @@ export class TSInteropArgConvertor {
         return convertType(this, type);
     }
     convertContainer(type) {
+        switch (type.elementType[0]) {
+            case idl.IDLU8Type: return 'KUint8ArrayPtr';
+            case idl.IDLI32Type: return 'KInt32ArrayPtr';
+            case idl.IDLF32Type: return 'KFloat32ArrayPtr';
+        }
         throw new Error(`Cannot pass container types through interop`);
     }
     convertImport(type) {
@@ -263,13 +283,17 @@ export class TSInteropArgConvertor {
             case idl.IDLF64Type: return "KDouble";
             case idl.IDLNumberType: return 'number';
             case idl.IDLBigintType: return 'bigint';
-            case idl.IDLBooleanType:
+            case idl.IDLBooleanType: return 'boolean';
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
             case idl.IDLBufferType: return 'ArrayBuffer';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
+            case idl.IDLInteropReturnBufferType: return `KInteropReturnBuffer`;
+            case idl.IDLObjectType: return 'Object';
+            case idl.IDLAnyType: return "Object";
             case idl.IDLDate: return 'number';
+            case idl.IDLVoidType: return 'void';
             case idl.IDLUndefinedType:
-            case idl.IDLVoidType:
             case idl.IDLPointerType: return 'KPointer';
         }
         throw new Error(`Cannot pass primitive type ${type.name} through interop`);
@@ -287,4 +311,34 @@ export class TSInteropArgConvertor {
         throw new Error("Cannot pass union types through interop");
     }
 }
+function applySubstitution(subst, type) {
+    var _a;
+    if (idl.isContainerType(type)) {
+        return idl.createContainerType(type.containerKind, type.elementType.map(it => applySubstitution(subst, it)));
+    }
+    if (idl.isReferenceType(type)) {
+        return idl.createReferenceType(type.name, (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => applySubstitution(subst, it)));
+    }
+    if (idl.isTypeParameterType(type)) {
+        const record = subst.get(type.name);
+        if (record) {
+            return record;
+        }
+    }
+    return type;
+}
+// Update parents to properly find a file for conflicted types
+function updateParent(parent, type) {
+    type.parent = parent;
+    if (idl.isOptionalType(type))
+        updateParent(type, type.type);
+    if (idl.isUnionType(type))
+        updateParents(type, type.types);
+    if (idl.isContainerType(type))
+        updateParents(type, type.elementType);
+}
+function updateParents(parent, types) {
+    for (const type of types)
+        updateParent(parent, type);
+}
 //# sourceMappingURL=TSConvertors.js.map

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

@@ -1,8 +1,9 @@
 import { Language } from "../Language";
-import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
+import { LibraryInterface } from "../LibraryInterface";
+import { PeerLibrary } from "../peer-generation/PeerLibrary";
 import { LanguageWriter } from "./LanguageWriter";
-import { TypeConvertor } from "./nameConvertor";
+import { IdlNameConvertor } from "./nameConvertor";
 export * from "./nameConvertor";
-export declare function createLanguageWriter(language: Language, resolver?: ReferenceResolver): LanguageWriter;
-export declare function createInteropArgConvertor(language: Language): TypeConvertor<string>;
+export declare function createLanguageWriter(language: Language, library: LibraryInterface, nameConvertor?: IdlNameConvertor): LanguageWriter;
+export declare function createInteropArgConvertor(language: Language, library: PeerLibrary): IdlNameConvertor;
 //# sourceMappingURL=index.d.ts.map