@idlizer/core 2.1.2 → 2.1.7

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`;
@@ -43,20 +48,20 @@ export class CJTypeNameConvertor {
         throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
     }
     convertNamespace(node) {
-        throw new Error('Method not implemented.');
+        return node.name;
     }
     convertInterface(node) {
-        return node.name;
+        return removePoints(idl.getNamespaceName(node).concat(node.name));
     }
     convertEnum(node) {
-        return node.name;
+        return removePoints(idl.getNamespaceName(node).concat(node.name));
     }
     convertTypedef(node) {
         return node.name;
     }
     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);
@@ -86,13 +95,18 @@ export class CJTypeNameConvertor {
                 return this.productType(decl, isTuple, !isTuple);
             }
         }
-        return type.name;
+        let name = type.name.split('.');
+        if (decl) {
+            return idl.getNamespacesPathFor(decl).map(ns => ns.name).join().concat(name[name.length - 1]);
+        }
+        return name[name.length - 1];
     }
     convertTypeParameter(type) {
         return type.name;
     }
     convertPrimitiveType(type) {
         switch (type) {
+            case idl.IDLThisType: return 'this';
             case idl.IDLStringType: return 'String';
             case idl.IDLBooleanType: return 'Bool';
             case idl.IDLNumberType: return 'Float64';
@@ -112,6 +126,12 @@ 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';
+            case idl.IDLDate: return 'DateTime';
+            case idl.IDLUnknownType:
+            case idl.IDLFunctionType:
+            case idl.IDLCustomObjectType: return 'Any';
         }
         throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -120,8 +140,6 @@ export class CJTypeNameConvertor {
         return `((${params.join(", ")}) -> ${this.convert(decl.returnType)})`;
     }
     productType(decl, isTuple, includeFieldNames) {
-        if (!isTuple)
-            throw new Error('Only tuples supported from IDL synthetic types for now');
         return decl.name;
     }
 }
@@ -131,6 +149,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,9 +181,11 @@ export class CJInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type) {
         switch (type) {
             case idl.IDLNumberType: return "Float64";
-            case idl.IDLLengthType: return "Ark_Length";
         }
         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

@@ -5,6 +5,7 @@ import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
 export interface ConvertResult {
     text: string;
     noPrefix: boolean;
+    resolvedType: idl.IDLType;
 }
 export declare class GenericCppConvertor implements NodeConvertor<ConvertResult> {
     protected resolver: ReferenceResolver;
@@ -21,7 +22,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 +53,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

@@ -26,8 +26,8 @@ export class GenericCppConvertor {
     constructor(resolver) {
         this.resolver = resolver;
     }
-    make(text, noPrefix = false) {
-        return { text, noPrefix };
+    make(text, resolvedType, noPrefix = false) {
+        return { text, noPrefix, resolvedType };
     }
     convertNode(node) {
         return convertNode(this, node);
@@ -39,70 +39,74 @@ export class GenericCppConvertor {
         switch (node.subkind) {
             case idl.IDLInterfaceSubkind.AnonymousInterface:
                 return node.name
-                    ? this.make(this.qualifiedName(node))
-                    : this.make(this.computeTargetTypeLiteralName(node), true);
+                    ? this.make(this.qualifiedName(node), idl.createReferenceType(node))
+                    : this.make(this.computeTargetTypeLiteralName(node), idl.createReferenceType(node), true);
             case idl.IDLInterfaceSubkind.Interface:
             case idl.IDLInterfaceSubkind.Class:
                 if (isInIdlizeInternal(node)) {
-                    return this.make(this.qualifiedName(node), true);
+                    return this.make(this.qualifiedName(node), idl.createReferenceType(node), true);
                 }
-                return this.make(this.qualifiedName(node));
+                return this.make(this.qualifiedName(node), idl.createReferenceType(node));
             case idl.IDLInterfaceSubkind.Tuple:
                 return node.name
-                    ? this.make(this.qualifiedName(node))
-                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
+                    ? this.make(this.qualifiedName(node), idl.createReferenceType(node))
+                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, idl.createReferenceType(node), true);
         }
     }
     convertEnum(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     convertTypedef(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     convertCallback(node) {
-        return this.make(generatorConfiguration().LibraryPrefix + this.qualifiedName(node), true);
+        return this.make(generatorConfiguration().LibraryPrefix + this.qualifiedName(node), idl.createReferenceType(node), true);
     }
     convertMethod(node) {
-        return this.make(node.name);
+        return this.make(node.name, idl.createReferenceType(node));
     }
     convertConstant(node) {
-        return this.make(this.qualifiedName(node));
+        return this.make(this.qualifiedName(node), idl.createReferenceType(node));
     }
     /////////////////////////////////////////////////////////////////////////////////////////
     convertOptional(type) {
-        return this.convertNode(type.type);
+        const converted = this.convertNode(type.type);
+        const prefix = generatorConfiguration().OptionalPrefix;
+        if (idl.isOptionalType(converted.resolvedType)) {
+            return converted;
+        }
+        return this.make(prefix + converted.text, type, true);
     }
     convertUnion(type) {
-        return this.make(type.name, false);
+        return this.make(type.name, type, false);
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isPromise(type)) {
-            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
+            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*`, true);
+                return this.make(`uint8_t*`, type, true);
             }
-            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, 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}`, true);
+            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, _) {
-        return this.make(idl.IDLCustomObjectType.name);
+    convertImport(type) {
+        console.warn("Imports are not implemented yet");
+        return this.make(idl.IDLCustomObjectType.name, idl.IDLCustomObjectType);
+    }
+    convertTypeReferenceAsImport(type, _) {
+        return this.convertTypeReference(type);
     }
     convertTypeReference(type) {
         var _a;
         const refName = type.name;
-        switch (refName) {
-            case "object":
-            case "Object":
-                return this.make('CustomObject');
-        }
         if (generatorConfiguration().parameterized.includes(refName)) {
-            return this.make('CustomObject');
+            return this.make('CustomObject', idl.IDLCustomObjectType);
         }
         let decl = this.resolver.toDeclaration(type);
         if (idl.isCallback(decl)) {
@@ -110,51 +114,52 @@ export class GenericCppConvertor {
         }
         if (idl.isType(decl)) {
             if (idl.isReferenceType(decl)) {
-                return this.make(`${capitalize(decl.name)}`);
+                return this.make(`${capitalize(decl.name)}`, decl);
             }
             return this.convertNode(decl);
         }
         let res = this.convertNode(decl);
         if (type.name === "Optional")
-            res = this.make("Opt_" + res.text, true);
+            res = this.make("Opt_" + res.text, idl.createOptionalType(type.typeArguments[0]), true);
         return res;
     }
     convertTypeParameter(type) {
-        return this.make('CustomObject');
+        return this.make('CustomObject', idl.IDLCustomObjectType);
     }
     convertPrimitiveType(type) {
         switch (type) {
-            case idl.IDLVoidType: return this.make('void', true);
-            case idl.IDLI8Type: return this.make(`Int8`);
-            case idl.IDLU8Type: return this.make(`UInt8`);
-            case idl.IDLI16Type: return this.make(`Int16`);
-            case idl.IDLU16Type: return this.make(`UInt16`);
-            case idl.IDLI32Type: return this.make(`Int32`);
-            case idl.IDLU32Type: return this.make(`UInt32`);
-            case idl.IDLI64Type: return this.make(`Int64`);
-            case idl.IDLU64Type: return this.make(`UInt64`);
-            case idl.IDLF32Type: return this.make(`Float32`);
-            case idl.IDLF64Type: return this.make(`Float64`);
-            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.IDLPointerType: return this.make('NativePointer');
-            case idl.IDLCustomObjectType: return this.make('CustomObject');
+            case idl.IDLThisType: // maybe fix it in another level?
+            case idl.IDLVoidType: return this.make('void', type, true);
+            case idl.IDLI8Type: return this.make(`Int8`, type);
+            case idl.IDLU8Type: return this.make(`UInt8`, type);
+            case idl.IDLI16Type: return this.make(`Int16`, type);
+            case idl.IDLU16Type: return this.make(`UInt16`, type);
+            case idl.IDLI32Type: return this.make(`Int32`, type);
+            case idl.IDLU32Type: return this.make(`UInt32`, type);
+            case idl.IDLI64Type: return this.make(`Int64`, type);
+            case idl.IDLU64Type: return this.make(`UInt64`, type);
+            case idl.IDLF32Type: return this.make(`Float32`, type);
+            case idl.IDLF64Type: return this.make(`Float64`, type);
+            case idl.IDLNumberType: return this.make(`Number`, type);
+            case idl.IDLStringType: return this.make(`String`, type);
+            case idl.IDLBooleanType: return this.make(`Boolean`, type);
+            case idl.IDLBigintType: return this.make(`Int64`, type); // TODO add arbitrary precision numeric type
+            case idl.IDLPointerType: return this.make('NativePointer', type);
+            case idl.IDLCustomObjectType: return this.make('CustomObject', type);
             case idl.IDLUnknownType:
-            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 };
+            case idl.IDLObjectType:
+            case idl.IDLAnyType: return this.make(`Object`, type);
+            case idl.IDLUndefinedType: return this.make(`Undefined`, type);
+            case idl.IDLFunctionType: return this.make(`Function`, type);
+            case idl.IDLDate: return this.make(`Date`, type);
+            case idl.IDLBufferType: return this.make('Buffer', type);
+            case idl.IDLPointerType: return this.make('Pointer', type);
+            case idl.IDLSerializerBuffer: return this.make('KSerializerBuffer', type, 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();
@@ -171,9 +176,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;
         }
@@ -187,12 +189,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);
@@ -221,7 +227,6 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
             case idl.IDLNumberType: return "KInteropNumber";
             case idl.IDLSerializerBuffer: return "KSerializerBuffer";
             case idl.IDLBufferType: return "KInteropBuffer";
-            case idl.IDLLengthType: return "KLength";
             case idl.IDLFunctionType: return PrimitiveTypesInstance.Int32.getText();
             case idl.IDLDate: return PrimitiveTypesInstance.Int64.getText();
             case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
@@ -247,7 +252,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) {
@@ -264,7 +273,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.d.ts

@@ -4,7 +4,7 @@ export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type: idl.IDLReferenceType): string;
     convertContainer(type: idl.IDLContainerType): string;
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
-    protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;
+    protected productType(decl: idl.IDLInterface, args: idl.IDLType[] | undefined, isTuple: boolean, includeFieldNames: boolean): string;
     protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
     protected mapCallback(decl: idl.IDLCallback): string;
     protected mapFunctionType(typeArgs: string[]): string;

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>";
@@ -77,14 +66,15 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
             case idl.IDLStringType: return 'string';
             case idl.IDLFunctionType: return 'Object';
             case idl.IDLBigintType: return 'long';
+            case idl.IDLCustomObjectType: return 'object';
         }
         return super.convertPrimitiveType(type);
     }
-    productType(decl, isTuple, includeFieldNames) {
+    productType(decl, args, isTuple, includeFieldNames) {
         if (decl.subkind === idl.IDLInterfaceSubkind.AnonymousInterface) {
             return decl.name;
         }
-        return super.productType(decl, isTuple, includeFieldNames);
+        return super.productType(decl, args, isTuple, includeFieldNames);
     }
     processTupleType(idlProperty) {
         if (idlProperty.isOptional) {

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;
     }
@@ -63,6 +66,7 @@ export class InteropReturnTypeConvertor {
             case idl.IDLThisType:
             case idl.IDLUndefinedType:
             case idl.IDLUnknownType:
+            case idl.IDLObjectType:
             case idl.IDLVoidType: return idl.IDLVoidType.name;
             case idl.IDLBufferType: return KInteropReturnBuffer; /* ArkTS can not return buffer as language object yet */
             case idl.IDLStringType: return PrimitiveTypesInstance.String.getText();
@@ -105,7 +109,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) {
@@ -116,6 +123,7 @@ 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';
@@ -124,7 +132,6 @@ export class InteropArgConvertor {
             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,22 +15,26 @@ 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;
     protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
-    protected mapCallback(decl: idl.IDLCallback): string;
-    protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;
+    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;
 }
 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;
 }