@idlizer/core 2.1.0 → 2.1.5

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

@@ -20,6 +20,11 @@ export class CJTypeNameConvertor {
         this.resolver = resolver;
     }
     convert(node) {
+        if (idl.isType(node) && idl.isReferenceType(node)) {
+            if (node.name.startsWith('%TEXT%:')) {
+                return node.name.substring(7);
+            }
+        }
         return convertNode(this, node);
     }
     /***** TypeConvertor<string> **********************************/
@@ -35,7 +40,7 @@ export class CJTypeNameConvertor {
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
             const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
-            return `Map<${stringes[0]}, ${stringes[1]}>`;
+            return `HashMap<${stringes[0]}, ${stringes[1]}>`;
         }
         if (idl.IDLContainerUtils.isPromise(type)) {
             return `Any`;
@@ -56,7 +61,7 @@ export class CJTypeNameConvertor {
     }
     convertCallback(type) {
         const params = type.parameters.map(it => `${it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
-        return `\{(${params.join(", ")}) => ${this.convert(type.returnType)}\}`;
+        return `(${params.join(", ")}) -> ${this.convert(type.returnType)}`;
     }
     convertMethod(node) {
         throw new Error('Method not implemented.');
@@ -64,7 +69,11 @@ export class CJTypeNameConvertor {
     convertConstant(node) {
         throw new Error('Method not implemented.');
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return type.name;
+    }
+    convertTypeReferenceAsImport(type, importClause) {
         return type.name;
     }
     convertTypeReference(type) {
@@ -72,7 +81,7 @@ export class CJTypeNameConvertor {
             return "KPointer";
         const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
         if (importAttr) {
-            return this.convertImport(type, importAttr);
+            return this.convertTypeReferenceAsImport(type, importAttr);
         }
         // resolve synthetic types
         const decl = this.resolver.resolveTypeReference(type);
@@ -112,6 +121,8 @@ export class CJTypeNameConvertor {
             case idl.IDLBufferType: return 'Array<UInt8>';
             case idl.IDLInteropReturnBufferType: return 'Array<UInt8>';
             case idl.IDLBigintType: return 'Int64';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
+            case idl.IDLAnyType: return 'Any';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -131,6 +142,7 @@ export class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
             switch (type) {
                 case idl.IDLStringType: return 'CString';
                 case idl.IDLInteropReturnBufferType: return 'KInteropReturnBuffer';
+                case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             }
         }
         if (idl.isContainerType(type)) {
@@ -162,7 +174,6 @@ export class CJInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type) {
         switch (type) {
             case idl.IDLNumberType: return "Float64";
-            case idl.IDLLengthType: return "Ark_Length";
         }
         return super.convertPrimitiveType(type);
     }

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

@@ -21,7 +21,8 @@ export declare class GenericCppConvertor implements NodeConvertor<ConvertResult>
     convertOptional(type: idl.IDLOptionalType): ConvertResult;
     convertUnion(type: idl.IDLUnionType): ConvertResult;
     convertContainer(type: idl.IDLContainerType): ConvertResult;
-    convertImport(type: idl.IDLReferenceType, _: string): ConvertResult;
+    convertImport(type: idl.IDLImport): ConvertResult;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, _: string): ConvertResult;
     convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
     convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
     convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
@@ -51,7 +52,8 @@ export declare class CppReturnTypeConvertor implements TypeConvertor<string> {
     isVoid(returnType: idl.IDLType): boolean;
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;

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

@@ -70,7 +70,7 @@ export class GenericCppConvertor {
     }
     /////////////////////////////////////////////////////////////////////////////////////////
     convertOptional(type) {
-        return this.convertNode(type.type);
+        return { text: generatorConfiguration().OptionalPrefix + this.convertNode(type.type).text, noPrefix: true };
     }
     convertUnion(type) {
         return this.make(type.name, false);
@@ -90,16 +90,21 @@ export class GenericCppConvertor {
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
-    convertImport(type, _) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
         return this.make(idl.IDLCustomObjectType.name);
     }
+    convertTypeReferenceAsImport(type, _) {
+        return this.convertTypeReference(type);
+    }
     convertTypeReference(type) {
         var _a;
         const refName = type.name;
         switch (refName) {
             case "object":
             case "Object":
-                return this.make('CustomObject');
+                // treat object as interop resource
+                return this.make('Object');
         }
         if (generatorConfiguration().parameterized.includes(refName)) {
             return this.make('CustomObject');
@@ -138,22 +143,22 @@ export class GenericCppConvertor {
             case idl.IDLNumberType: return this.make(`Number`);
             case idl.IDLStringType: return this.make(`String`);
             case idl.IDLBooleanType: return this.make(`Boolean`);
-            case idl.IDLBigintType: return this.make(`UInt64`); // TODO add arbitrary precision numeric type
+            case idl.IDLBigintType: return this.make(`Int64`); // TODO add arbitrary precision numeric type
             case idl.IDLPointerType: return this.make('NativePointer');
+            case idl.IDLCustomObjectType: return this.make('CustomObject');
             case idl.IDLUnknownType:
-            case idl.IDLCustomObjectType:
-            case idl.IDLAnyType: return this.make(`CustomObject`);
+            case idl.IDLAnyType: return this.make(`Object`);
             case idl.IDLUndefinedType: return this.make(`Undefined`);
-            case idl.IDLLengthType: return this.make(`Length`);
             case idl.IDLFunctionType: return this.make(`Function`);
             case idl.IDLDate: return this.make(`Date`);
             case idl.IDLBufferType: return this.make('Buffer');
             case idl.IDLPointerType: return this.make('Pointer');
+            case idl.IDLSerializerBuffer: return { text: 'KSerializerBuffer', noPrefix: true };
         }
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }
     qualifiedName(target) {
-        return qualifiedName(target, "_");
+        return qualifiedName(target, "_", "namespace.name");
     }
     computeTargetTypeLiteralName(decl) {
         const map = new Map();
@@ -170,9 +175,6 @@ export class GenericCppConvertor {
 export class CppConvertor extends GenericCppConvertor {
     unwrap(type, result) {
         const conf = generatorConfiguration();
-        if (idl.isType(type) && idl.isOptionalType(type)) {
-            return `${conf.OptionalPrefix}${result.text}`;
-        }
         if (result.noPrefix) {
             return result.text;
         }
@@ -186,12 +188,16 @@ export class CppConvertor extends GenericCppConvertor {
         if (!idl.isType(type))
             return false;
         const { resolver } = this;
+        const seen = new Set;
         while (type && idl.isReferenceType(type)) {
             const resolved = resolver.resolveTypeReference(type);
             if (!resolved)
                 return false;
             if (!idl.isTypedef(resolved))
                 break;
+            if (seen.has(resolved))
+                return false;
+            seen.add(resolved);
             type = resolved.type;
         }
         return idl.isPrimitiveType(type);
@@ -218,8 +224,8 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
             case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
             case idl.IDLI32Type: return PrimitiveTypesInstance.Int32.getText();
             case idl.IDLNumberType: return "KInteropNumber";
-            case idl.IDLBufferType: return "Ark_Buffer";
-            case idl.IDLLengthType: return "KLength";
+            case idl.IDLSerializerBuffer: return "KSerializerBuffer";
+            case idl.IDLBufferType: return "KInteropBuffer";
             case idl.IDLFunctionType: return PrimitiveTypesInstance.Int32.getText();
             case idl.IDLDate: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
@@ -245,7 +251,11 @@ export class CppReturnTypeConvertor {
             return 'void';
         return this.convertor.convert(type);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return "void";
+    }
+    convertTypeReferenceAsImport(type, importClause) {
         return this.convertor.convert(type);
     }
     convertOptional(type) {
@@ -262,7 +272,7 @@ export class CppReturnTypeConvertor {
     convertTypeReference(type) {
         const decl = this.resolver.resolveTypeReference(type);
         if (decl && idl.isInterface(decl) && isMaterialized(decl, this.resolver)) {
-            return generatorTypePrefix() + qualifiedName(decl, "_");
+            return generatorTypePrefix() + qualifiedName(decl, "_", "namespace.name");
         }
         return this.convertor.convert(type);
     }

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

@@ -13,27 +13,16 @@
  * limitations under the License.
  */
 import * as idl from "../../idl";
-import { Language } from "../../Language";
-import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
-import { convertDeclaration } from "../nameConvertor";
+import { LanguageWriter } from "../LanguageWriter";
 import { TSInteropArgConvertor, TSTypeNameConvertor } from "./TSConvertors";
 export class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type) {
-        // Only to deal with namespaces. TODO: remove later
-        const decl = this.resolver.resolveTypeReference(type);
-        if (decl && idl.isEnum(decl)) {
-            return convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), decl);
+        let typeName = super.convertTypeReference(type);
+        if (LanguageWriter.isReferenceRelativeToNamespaces && idl.isReferenceType(type)) {
+            const namespacesPath = idl.getNamespacesPathFor(type).map(it => `${it.name}.`).join("");
+            if (typeName.startsWith(namespacesPath))
+                typeName = typeName.substring(namespacesPath.length);
         }
-        // TODO: Needs to be implemented properly
-        const types = type.name.split(".");
-        if (types.length > 1) {
-            // Takes only name without the namespace prefix
-            const decl = this.resolver.resolveTypeReference(idl.createReferenceType(types.slice(-1).join()));
-            if (decl !== undefined) {
-                return convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), decl);
-            }
-        }
-        const typeName = super.convertTypeReference(type);
         // TODO: Fix for 'TypeError: Type 'Function<R>' is generic but type argument were not provided.'
         if (typeName === "Function") {
             return "Function<void>";
@@ -76,8 +65,8 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
                 return 'number';
             case idl.IDLStringType: return 'string';
             case idl.IDLFunctionType: return 'Object';
-            case idl.IDLBufferType: return 'NativeBuffer';
             case idl.IDLBigintType: return 'long';
+            case idl.IDLCustomObjectType: return 'object';
         }
         return super.convertPrimitiveType(type);
     }

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

@@ -9,7 +9,8 @@ export declare class InteropReturnTypeConvertor implements TypeConvertor<string>
     isReturnInteropBuffer(type: idl.IDLType): boolean;
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
@@ -19,7 +20,8 @@ export declare class InteropReturnTypeConvertor implements TypeConvertor<string>
 export declare class InteropArgConvertor implements TypeConvertor<string> {
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;

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

@@ -37,9 +37,12 @@ export class InteropReturnTypeConvertor {
         }
         return KInteropReturnBuffer;
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
         throw new Error(`Cannot pass import type ${type.name} through interop`);
     }
+    convertTypeReferenceAsImport(type, importClause) {
+        return this.convertTypeReference(type);
+    }
     convertOptional(type) {
         return KInteropReturnBuffer;
     }
@@ -88,6 +91,9 @@ export class InteropReturnTypeConvertor {
                 }
                 return KInteropReturnBuffer;
             }
+            if (idl.isEnum(decl)) {
+                return PrimitiveTypesInstance.Int32.getText();
+            }
         }
         return "void";
     }
@@ -102,7 +108,10 @@ export class InteropArgConvertor {
     convertContainer(type) {
         throw new Error(`Cannot pass container types through interop`);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertTypeReferenceAsImport(type, importClause) {
         throw new Error(`Cannot pass import types through interop`);
     }
     convertOptional(type) {
@@ -113,14 +122,15 @@ export class InteropArgConvertor {
             case idl.IDLI64Type: return "KLong";
             case idl.IDLU64Type: return "KLong";
             case idl.IDLI32Type: return "KInt";
+            case idl.IDLU32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
             case idl.IDLNumberType: return 'KInteropNumber';
             case idl.IDLBigintType: return 'KLong';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
             case idl.IDLBufferType: return `KInteropBuffer`;
-            case idl.IDLLengthType: return 'Length';
             case idl.IDLDate: return 'KLong';
             case idl.IDLUndefinedType:
             case idl.IDLVoidType:

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

@@ -17,7 +17,8 @@ export declare class JavaTypeNameConvertor implements NodeConvertor<string>, Idl
     convertCallback(type: idl.IDLCallback): string;
     convertMethod(type: idl.IDLMethod): string;
     convertConstant(type: idl.IDLConstant): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;

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

@@ -84,13 +84,17 @@ export class JavaTypeNameConvertor {
     convertConstant(type) {
         throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return type.name;
+    }
+    convertTypeReferenceAsImport(type, importClause) {
         return type.name;
     }
     convertTypeReference(type) {
         const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
         if (importAttr) {
-            return this.convertImport(type, importAttr);
+            return this.convertTypeReferenceAsImport(type, importAttr);
         }
         const decl = this.resolver.resolveTypeReference(type);
         if (decl) {
@@ -127,6 +131,9 @@ export class JavaTypeNameConvertor {
             case idl.IDLDate: return 'Date';
             case idl.IDLBufferType: return 'byte[]';
             case idl.IDLInteropReturnBufferType: return 'byte[]';
+            case idl.IDLSerializerBuffer: return 'long';
+            case idl.IDLAnyType: return 'Ark_Object';
+            case idl.IDLUnknownType: return 'Ark_Object';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -154,7 +161,7 @@ export class JavaTypeNameConvertor {
             case 'KStringPtr': return 'String';
             case 'string': return 'String';
         }
-        return name;
+        return name.split(".").at(-1);
     }
 }
 class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
@@ -178,8 +185,21 @@ export class JavaInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type) {
         switch (type) {
             case idl.IDLNumberType: return "double";
-            case idl.IDLLengthType: return "String";
             case idl.IDLBooleanType: return "boolean";
+            case idl.IDLI64Type: return "long";
+            case idl.IDLU64Type: return "long";
+            case idl.IDLI32Type: return "int";
+            case idl.IDLU32Type: return "int";
+            case idl.IDLF32Type: return "float";
+            case idl.IDLBigintType: return "long";
+            case idl.IDLSerializerBuffer: return "long";
+            case idl.IDLFunctionType: return "int";
+            case idl.IDLStringType: return "String";
+            case idl.IDLBufferType: return "byte[]";
+            case idl.IDLDate: return "long";
+            case idl.IDLVoidType: return "void";
+            case idl.IDLUndefinedType: return "long";
+            case idl.IDLPointerType: return "long"; // return PrimitiveTypesInstance.NativePointer.getText()
         }
         return super.convertPrimitiveType(type);
     }

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

@@ -15,7 +15,8 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
     convertOptional(type: idl.IDLOptionalType): string;
     convertUnion(type: idl.IDLUnionType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
@@ -27,10 +28,11 @@ export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNa
 export declare class TSInteropArgConvertor implements TypeConvertor<string> {
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;
-    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertImport(type: idl.IDLImport): string;
     convertOptional(type: idl.IDLOptionalType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
     convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): string;
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertUnion(type: idl.IDLUnionType): string;
 }

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

@@ -25,16 +25,18 @@ export class TSTypeNameConvertor {
         return node.name;
     }
     convertInterface(node) {
-        return idl.getFQName(node);
+        return idl.getQualifiedName(node, "namespace.name");
     }
     convertEnum(node) {
-        return idl.getFQName(node);
+        return idl.getQualifiedName(node, "namespace.name");
     }
     convertTypedef(node) {
         return node.name;
     }
     convertCallback(node) {
-        return node.name;
+        return idl.isSyntheticEntry(node)
+            ? this.mapCallback(node)
+            : node.name;
     }
     convertMethod(node) {
         return node.name;
@@ -72,11 +74,23 @@ export class TSTypeNameConvertor {
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
         return type.name;
     }
+    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);
+        if (decl)
+            return `${decl.name}${maybeTypeArguments}`;
+        return `${type.name}${maybeTypeArguments}`;
+    }
     convertTypeReference(type) {
         var _a, _b;
+        if (type.name === idl.IDLObjectType.name) {
+            return type.name;
+        }
         let decl = this.resolver.resolveTypeReference(type);
         if (decl) {
             if (idl.isSyntheticEntry(decl)) {
@@ -89,39 +103,42 @@ export class TSTypeNameConvertor {
                     return this.productType(decl, isTuple, !isTuple);
                 }
             }
+            // FIXME: isEnumMember is not TYPE!
+            if (decl && idl.isEnumMember(decl) && decl.parent) {
+                // when `interface A { field?: MyEnum.Value1 }` is generated, it is not possible
+                // to deserialize A, because there is no such type information in declaration target
+                // (can not cast MyEnum to exact MyEnum.Value1)
+                decl = decl.parent;
+            }
+            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 : [];
+            if (typeSpec === `Optional`)
+                return `${typeArgs} | undefined`;
+            if (typeSpec === `Function`)
+                return this.mapFunctionType(typeArgs);
+            const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
+            if (decl) {
+                const path = idl.getNamespacesPathFor(decl).map(it => it.name);
+                path.push(decl.name);
+                return `${path.join(".")}${maybeTypeArguments}`;
+            }
+            return `${type.name}${maybeTypeArguments}`;
         }
-        // FIXME: isEnumMember is not TYPE!
-        if (decl && idl.isEnumMember(decl) && decl.parent) {
-            // when `interface A { field?: MyEnum.Value1 }` is generated, it is not possible
-            // to deserialize A, because there is no such type information in declaration target
-            // (can not cast MyEnum to exact MyEnum.Value1)
-            decl = decl.parent;
-        }
-        let typeSpec = type.name;
-        let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => idl.printType(it))) !== null && _b !== void 0 ? _b : [];
-        if (typeSpec === `Optional`)
-            return `${typeArgs} | undefined`;
-        if (typeSpec === `Function`)
-            return this.mapFunctionType(typeArgs);
-        const maybeTypeArguments = !(typeArgs === null || typeArgs === void 0 ? void 0 : typeArgs.length) ? '' : `<${typeArgs.join(', ')}>`;
-        if (decl) {
-            const path = idl.getNamespacesPathFor(decl).map(it => it.name);
-            path.push(decl.name);
-            return `${path.join(".")}${maybeTypeArguments}`;
-        }
-        return `${type.name}${maybeTypeArguments}`;
+        return this.convert(idl.IDLCustomObjectType);
     }
     convertTypeParameter(type) {
         return type.name;
     }
     convertPrimitiveType(type) {
         switch (type) {
+            case idl.IDLFunctionType: return 'Function';
             case idl.IDLUnknownType:
             case idl.IDLCustomObjectType: return 'unknown';
             case idl.IDLThisType: return 'this';
             case idl.IDLAnyType: return 'any';
             case idl.IDLUndefinedType: return 'undefined';
             case idl.IDLPointerType: return 'KPointer';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLVoidType: return 'void';
             case idl.IDLBooleanType: return 'boolean';
             case idl.IDLI32Type:
@@ -145,7 +162,7 @@ export class TSTypeNameConvertor {
             case idl.IDLDate:
                 return 'Date';
             case idl.IDLBufferType:
-                return `ArrayBuffer`;
+                return 'NativeBuffer';
             case idl.IDLInteropReturnBufferType:
                 return `KInteropReturnBuffer`;
         }
@@ -155,7 +172,7 @@ export class TSTypeNameConvertor {
         return idlProperty;
     }
     mapCallback(decl) {
-        const params = decl.parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}`);
+        const params = decl.parameters.map(it => `${it.isVariadic ? "..." : ""}${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}${it.isVariadic ? "[]" : ""}`);
         return `((${params.join(", ")}) => ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
@@ -180,7 +197,7 @@ export class TSInteropArgConvertor {
     convertContainer(type) {
         throw new Error(`Cannot pass container types through interop`);
     }
-    convertImport(type, importClause) {
+    convertImport(type) {
         throw new Error(`Cannot pass import types through interop`);
     }
     convertOptional(type) {
@@ -191,14 +208,14 @@ export class TSInteropArgConvertor {
             case idl.IDLI64Type: return "KLong";
             case idl.IDLU64Type: return "KLong";
             case idl.IDLI32Type: return "KInt";
+            case idl.IDLU32Type: return "KInt";
             case idl.IDLF32Type: return "KFloat";
             case idl.IDLNumberType: return 'number';
             case idl.IDLBigintType: return 'bigint';
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
-            case idl.IDLBufferType: return `ArrayBuffer`;
-            case idl.IDLLengthType: return 'Length';
+            case idl.IDLBufferType: return 'ArrayBuffer';
             case idl.IDLDate: return 'number';
             case idl.IDLUndefinedType:
             case idl.IDLVoidType:
@@ -209,6 +226,9 @@ export class TSInteropArgConvertor {
     convertTypeParameter(type) {
         throw new Error("Cannot pass type parameters through interop");
     }
+    convertTypeReferenceAsImport(type, importClause) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
     convertTypeReference(type) {
         throw new Error(`Cannot pass type references through interop`);
     }

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

@@ -6,13 +6,15 @@ export interface TypeConvertor<T> {
     convertOptional(type: idl.IDLOptionalType): T;
     convertUnion(type: idl.IDLUnionType): T;
     convertContainer(type: idl.IDLContainerType): T;
-    convertImport(type: idl.IDLReferenceType, importClause: string): T;
+    convertImport(type: idl.IDLImport): T;
+    convertTypeReferenceAsImport(type: idl.IDLReferenceType, importClause: string): T;
     convertTypeReference(type: idl.IDLReferenceType): T;
     convertTypeParameter(type: idl.IDLTypeParameterType): T;
     convertPrimitiveType(type: idl.IDLPrimitiveType): T;
 }
 export declare function convertType<T>(convertor: TypeConvertor<T>, type: idl.IDLType): T;
 export interface DeclarationConvertor<T> {
+    convertImport(node: idl.IDLImport): T;
     convertNamespace(node: idl.IDLNamespace): T;
     convertInterface(node: idl.IDLInterface): T;
     convertEnum(node: idl.IDLEnum): T;

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

@@ -20,10 +20,12 @@ export function convertType(convertor, type) {
         return convertor.convertUnion(type);
     if (idl.isContainerType(type))
         return convertor.convertContainer(type);
+    if (idl.isImport(type))
+        return convertor.convertImport(type);
     if (idl.isReferenceType(type)) {
         const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
         return importAttr
-            ? convertor.convertImport(type, importAttr)
+            ? convertor.convertTypeReferenceAsImport(type, importAttr)
             : convertor.convertTypeReference(type);
     }
     if (idl.isTypeParameterType(type))
@@ -33,6 +35,8 @@ export function convertType(convertor, type) {
     throw new Error(`Unknown type ${idl.IDLKind[type.kind]}`);
 }
 export function convertDeclaration(convertor, decl) {
+    if (idl.isImport(decl))
+        return convertor.convertImport(decl);
     if (idl.isNamespace(decl))
         return convertor.convertNamespace(decl);
     if (idl.isInterface(decl))