@idlizer/core 2.0.15 → 2.0.19

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

@@ -123,7 +123,7 @@ export class StringConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return writer.language == Language.CPP
             ? writer.makeUnsafeCast_(writer.makeString(`&${param}`), this.idlType, PrintHint.AsConstPointer)
-            : param;
+            : writer.escapeKeyword(param);
     }
     convertorSerialize(param, value, writer) {
         writer.writeMethodCall(`${param}Serializer`, `writeString`, [value]);
@@ -158,7 +158,7 @@ export class EnumConvertor extends BaseArgConvertor {
         this.enumEntry = enumEntry;
     }
     convertorArg(param, writer) {
-        return writer.makeEnumCast(param, false, this);
+        return writer.makeEnumCast(writer.escapeKeyword(param), false, this);
     }
     convertorSerialize(param, value, writer) {
         value =
@@ -199,7 +199,7 @@ export class NumberConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         return writer.language == Language.CPP
             ? writer.makeUnsafeCast_(writer.makeString(`&${param}`), this.idlType, PrintHint.AsConstPointer)
-            : param;
+            : writer.escapeKeyword(param);
     }
     convertorSerialize(param, value, printer) {
         printer.writeMethodCall(`${param}Serializer`, "writeNumber", [value]);
@@ -698,14 +698,26 @@ export class OptionConvertor extends BaseArgConvertor {
         const valueType = `${value}_type`;
         const serializedType = (printer.language == Language.JAVA ? undefined : idl.IDLI32Type);
         printer.writeStatement(printer.makeAssign(valueType, serializedType, printer.makeRuntimeType(RuntimeType.UNDEFINED), true, false));
-        printer.runtimeType(this, valueType, value);
-        printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(valueType, 8)]);
+        if (printer.language != Language.CJ) {
+            printer.runtimeType(this, valueType, value);
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", [printer.castToInt(valueType, 8)]);
+        }
         printer.print(`if (${printer.makeRuntimeTypeCondition(valueType, false, RuntimeType.UNDEFINED, value).asString()}) {`);
         printer.pushIndent();
+        if (printer.language == Language.CJ) {
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.OBJECT.ordinal"]); // everything is object, except None<T>
+        }
         printer.writeStatement(printer.makeAssign(`${value}_value`, undefined, printer.makeValueFromOption(value, this.typeConvertor), true));
         this.typeConvertor.convertorSerialize(param, this.typeConvertor.getObjectAccessor(printer.language, `${value}_value`), printer);
         printer.popIndent();
         printer.print(`}`);
+        if (printer.language == Language.CJ) {
+            printer.print('else {');
+            printer.pushIndent();
+            printer.writeMethodCall(`${param}Serializer`, "writeInt8", ["RuntimeType.UNDEFINED.ordinal"]); // undefined
+            printer.popIndent();
+            printer.print('}');
+        }
     }
     convertorCArg(param) {
         throw new Error("Must never be used");

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

@@ -273,6 +273,7 @@ export declare abstract class LanguageWriter {
     writeStatement(stmt: LanguageStatement): void;
     writeStatements(...statements: LanguageStatement[]): void;
     writeExpressionStatement(smth: LanguageExpression): void;
+    writeStaticBlock(op: (writer: this) => void): void;
     makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
     makeThis(): LanguageExpression;
     makeNull(value?: string): LanguageExpression;

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

@@ -281,11 +281,10 @@ export class LambdaExpression {
                 stmt.write(writer);
             }
         }
-        return writer.printer.getOutput()
-            .map(line => line.trim())
+        return writer.getOutput()
             .filter(line => line !== "")
-            .map(line => line === "{" || line === "}" || this.statementHasSemicolon ? line : `${line};`)
-            .join(" ");
+            .map(line => line.endsWith('{') || line.endsWith('}') || line.endsWith(';') ? line : `${line};`)
+            .join("\n");
     }
 }
 ////////////////////////////////////////////////////////////////
@@ -438,6 +437,13 @@ export class LanguageWriter {
     writeExpressionStatement(smth) {
         this.writeStatement(new ExpressionStatement(smth));
     }
+    writeStaticBlock(op) {
+        this.print("static {");
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.print("}");
+    }
     makeRef(type, _options) {
         return type;
     }

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

@@ -0,0 +1,30 @@
+import * as idl from '../../idl';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+export declare class CJTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    convert(node: idl.IDLNode): string;
+    /***** TypeConvertor<string> **********************************/
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertNamespace(node: idl.IDLNamespace): string;
+    convertInterface(node: idl.IDLInterface): string;
+    convertEnum(node: idl.IDLEnum): string;
+    convertTypedef(node: idl.IDLTypedef): string;
+    convertCallback(type: idl.IDLCallback): string;
+    convertMethod(node: idl.IDLMethod): string;
+    convertConstant(node: idl.IDLConstant): string;
+    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    private callbackType;
+    private productType;
+}
+export declare class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
+    convert(type: idl.IDLNode): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+}
+//# sourceMappingURL=CJConvertors.d.ts.map

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

@@ -0,0 +1,154 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as idl from '../../idl';
+import { convertNode, convertType } from '../nameConvertor';
+export class CJTypeNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    convert(node) {
+        return convertNode(this, node);
+    }
+    /***** TypeConvertor<string> **********************************/
+    convertOptional(type) {
+        return `Option<${this.convert(type.type)}>`;
+    }
+    convertUnion(type) {
+        return type.name;
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            return `ArrayList<${convertType(this, type.elementType[0])}>`;
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            const stringes = type.elementType.slice(0, 2).map(it => convertType(this, it));
+            return `Map<${stringes[0]}, ${stringes[1]}>`;
+        }
+        throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
+    }
+    convertNamespace(node) {
+        throw new Error('Method not implemented.');
+    }
+    convertInterface(node) {
+        return node.name;
+    }
+    convertEnum(node) {
+        return 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)}\}`;
+    }
+    convertMethod(node) {
+        throw new Error('Method not implemented.');
+    }
+    convertConstant(node) {
+        throw new Error('Method not implemented.');
+    }
+    convertImport(type, importClause) {
+        return type.name;
+    }
+    convertTypeReference(type) {
+        if (type.name === "Object")
+            return "KPointer";
+        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
+        if (importAttr) {
+            return this.convertImport(type, importAttr);
+        }
+        // resolve synthetic types
+        const decl = this.resolver.resolveTypeReference(type);
+        if (decl && idl.isSyntheticEntry(decl)) {
+            if (idl.isCallback(decl)) {
+                return this.callbackType(decl);
+            }
+            const entity = idl.getExtAttribute(decl, idl.IDLExtendedAttributes.Entity);
+            if (entity) {
+                const isTuple = entity === idl.IDLEntity.Tuple;
+                return this.productType(decl, isTuple, !isTuple);
+            }
+        }
+        return type.name;
+    }
+    convertTypeParameter(type) {
+        return type.name;
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLStringType: return 'String';
+            case idl.IDLBooleanType: return 'Bool';
+            case idl.IDLNumberType: return 'Float64';
+            case idl.IDLUndefinedType: return 'Unit'; // might be wrong
+            case idl.IDLI8Type: return 'Int8';
+            case idl.IDLU8Type: return 'UInt8';
+            case idl.IDLI16Type: return 'Int16';
+            case idl.IDLU16Type: return 'UInt16';
+            case idl.IDLI32Type: return 'Int32';
+            case idl.IDLU32Type: return 'UInt32';
+            case idl.IDLI64Type: return 'Int64';
+            case idl.IDLU64Type: return 'UInt64';
+            case idl.IDLF32Type: return 'Float32';
+            case idl.IDLF64Type: return 'Float64';
+            case idl.IDLPointerType: return 'UInt64';
+            case idl.IDLVoidType: return 'Unit';
+            case idl.IDLBufferType: return 'ArrayList<UInt8>';
+        }
+        throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    callbackType(decl) {
+        const params = decl.parameters.map(it => `${it.name}: ${it.isOptional ? "?" : ""}${this.convert(it.type)}`);
+        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;
+    }
+}
+export class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvertor {
+    convert(type) {
+        if (idl.isPrimitiveType(type)) {
+            switch (type) {
+                case idl.IDLStringType: return 'CString';
+            }
+        }
+        if (idl.isContainerType(type)) {
+            if (idl.IDLContainerUtils.isSequence(type)) {
+                return `CPointer<${this.convert(type.elementType[0])}>`;
+            }
+        }
+        if (idl.isReferenceType(type)) {
+            // Fix, actual mapping has to be due to IDLType
+            if (super.convert(type).startsWith('Array'))
+                return `CPointer<UInt8>`;
+            if (super.convert(type) == 'String' || super.convert(type) == 'KStringPtr') {
+                return `CString`;
+            }
+            if (super.convert(type) == 'Object') {
+                return `KPointer`;
+            }
+        }
+        return super.convert(type);
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLBufferType: return 'CPointer<UInt8>';
+        }
+        return super.convertPrimitiveType(type);
+    }
+}
+//# sourceMappingURL=CJConvertors.js.map

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

@@ -17,15 +17,17 @@ import { generatorConfiguration } from "../../config";
 import { InteropConvertor } from '../InteropConvertor';
 export class CppInteropConvertor extends InteropConvertor {
     unwrap(type, result) {
+        const conf = generatorConfiguration();
         if (idl.isType(type) && idl.isOptionalType(type)) {
-            return `Opt_${result.text}`;
+            return `${conf.param("OptionalPrefix")}${result.text}`;
         }
         if (result.noPrefix) {
             return result.text;
         }
-        const conf = generatorConfiguration();
         const typePrefix = conf.param("TypePrefix");
-        const libPrefix = idl.isPrimitiveType(type) ? "" : conf.param("LibraryPrefix");
+        // TODO remove this ugly hack for CustomObject's
+        const convertedToCustomObject = result.text === idl.IDLCustomObjectType.name;
+        const libPrefix = idl.isPrimitiveType(type) || convertedToCustomObject ? "" : conf.param("LibraryPrefix");
         return `${typePrefix}${libPrefix}${result.text}`;
     }
     convert(node) {

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

@@ -0,0 +1,13 @@
+import * as idl from "../../idl";
+import { TSTypeNameConvertor } from "./TSConvertors";
+export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertEnum(node: idl.IDLEnum): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    protected productType(decl: idl.IDLInterface, isTuple: boolean, includeFieldNames: boolean): string;
+    protected processTupleType(idlProperty: idl.IDLProperty): idl.IDLProperty;
+    protected mapCallback(decl: idl.IDLCallback): string;
+    protected mapFunctionType(typeArgs: string[]): string;
+}
+//# sourceMappingURL=ETSConvertors.d.ts.map

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

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * 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 { 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);
+        }
+        // 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(), undefined, type));
+            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>";
+        }
+        return typeName;
+    }
+    convertEnum(node) {
+        let ns = idl.getNamespaceName(node).split('.').join('_');
+        if (ns !== '') {
+            ns += '_';
+        }
+        return ns + node.name;
+    }
+    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 super.convertContainer(type);
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLAnyType: return "object";
+            case idl.IDLUnknownType: return "object";
+            case idl.IDLPointerType: return 'KPointer';
+            case idl.IDLVoidType: return 'void';
+            case idl.IDLBooleanType: return 'boolean';
+            case idl.IDLU8Type:
+            case idl.IDLI8Type:
+            case idl.IDLI16Type:
+            case idl.IDLU16Type:
+            case idl.IDLI32Type:
+            case idl.IDLU32Type:
+                return 'int32';
+            case idl.IDLI64Type:
+            case idl.IDLU64Type:
+                return 'int64';
+            case idl.IDLF32Type:
+                return 'float32';
+            case idl.IDLF64Type:
+                return 'float64';
+            case idl.IDLNumberType:
+                return 'number';
+            case idl.IDLStringType: return 'string';
+            case idl.IDLFunctionType: return 'Object';
+            case idl.IDLBufferType: return 'NativeBuffer';
+        }
+        return super.convertPrimitiveType(type);
+    }
+    productType(decl, isTuple, includeFieldNames) {
+        if (decl.subkind === idl.IDLInterfaceSubkind.AnonymousInterface) {
+            return decl.name;
+        }
+        return super.productType(decl, isTuple, includeFieldNames);
+    }
+    processTupleType(idlProperty) {
+        if (idlProperty.isOptional) {
+            return Object.assign(Object.assign({}, idlProperty), { isOptional: false, type: idl.createUnionType([idlProperty.type, idl.IDLUndefinedType]) });
+        }
+        return idlProperty;
+    }
+    mapCallback(decl) {
+        const params = decl.parameters.map(it => {
+            return `${it.name}${it.isOptional ? "?" : ""}: ${this.convert(it.type)}`;
+        });
+        return `((${params.join(",")}) => ${this.convert(decl.returnType)})`;
+    }
+    mapFunctionType(typeArgs) {
+        // Fix for "TypeError: Type 'Function<R>' is generic but type argument were not provided."
+        // Replace "Function" to "Function<void>"
+        // Use "FunctionN" for ts compatibility
+        if (typeArgs.length === 0) {
+            typeArgs = [this.convert(idl.IDLVoidType)];
+        }
+        return `Function${typeArgs.length - 1}<${typeArgs.join(",")}>`;
+    }
+}
+//# sourceMappingURL=ETSConvertors.js.map

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

@@ -0,0 +1,32 @@
+import * as idl from '../../idl';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+export declare class JavaTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
+    private resolver;
+    constructor(resolver: ReferenceResolver);
+    protected solidConvertor: import("../../util").Lazy<JavaIdlNodeToSolidStringConvertor>;
+    convert(node: idl.IDLNode): string;
+    convertNamespace(node: idl.IDLNamespace): string;
+    convertInterface(node: idl.IDLInterface): string;
+    convertEnum(node: idl.IDLEnum): string;
+    convertTypedef(node: idl.IDLTypedef): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertCallback(type: idl.IDLCallback): string;
+    convertMethod(type: idl.IDLMethod): string;
+    convertConstant(type: idl.IDLConstant): string;
+    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    private readonly javaPrimitiveToReferenceTypeMap;
+    protected maybeConvertPrimitiveType(javaType: string): string;
+    private mapTypeName;
+}
+declare class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
+    protected solidConvertor: import("../../util").Lazy<this>;
+    convertContainer(type: idl.IDLContainerType): string;
+}
+export {};
+//# sourceMappingURL=JavaConvertors.d.ts.map

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

@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import * as idl from '../../idl';
+import { lazy } from '../../util';
+import { convertNode, convertType } from '../nameConvertor';
+function convertJavaOptional(type) {
+    switch (type) {
+        case 'boolean': return 'Opt_Boolean';
+        case 'double': return 'Opt_Number';
+    }
+    return type;
+}
+export class JavaTypeNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+        this.solidConvertor = lazy(() => new JavaIdlNodeToSolidStringConvertor(this.resolver));
+        this.javaPrimitiveToReferenceTypeMap = new Map([
+            ['byte', 'Byte'],
+            ['short', 'Short'],
+            ['int', 'Integer'],
+            ['float', 'Float'],
+            ['double', 'Double'],
+            ['boolean', 'Boolean'],
+            ['char', 'Character'],
+        ]);
+    }
+    convert(node) {
+        const typeString = convertNode(this, node);
+        return this.mapTypeName(typeString);
+    }
+    convertNamespace(node) {
+        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
+    }
+    convertInterface(node) {
+        if (node.subkind === idl.IDLInterfaceSubkind.Tuple) {
+            const javaTypeAliases = node.properties.map(it => convertType(this, idl.maybeOptional(it.type, it.isOptional)));
+            return `Tuple_${javaTypeAliases.join('_')}`;
+        }
+        return node.name;
+    }
+    convertEnum(node) {
+        return node.name;
+    }
+    convertTypedef(node) {
+        return node.name;
+    }
+    convertOptional(type) {
+        return convertJavaOptional(this.convert(type.type));
+    }
+    convertUnion(type) {
+        const aliases = type.types.map(it => convertType(this.solidConvertor.value, it));
+        return `Union_${aliases.join('_')}`;
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            const javaType = convertType(this, type.elementType[0]);
+            return `${javaType}[]`;
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            const javaTypes = type.elementType.slice(0, 2).map(it => convertType(this, it)).map(this.maybeConvertPrimitiveType, this);
+            return `Map<${javaTypes[0]}, ${javaTypes[1]}>`;
+        }
+        throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
+    }
+    convertCallback(type) {
+        return `Callback`;
+    }
+    convertMethod(type) {
+        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
+    }
+    convertConstant(type) {
+        throw new Error('Method not implemented.'); // TODO: namespace-related-to-rework
+    }
+    convertImport(type, importClause) {
+        return type.name;
+    }
+    convertTypeReference(type) {
+        const importAttr = idl.getExtAttribute(type, idl.IDLExtendedAttributes.Import);
+        if (importAttr) {
+            return this.convertImport(type, importAttr);
+        }
+        const decl = this.resolver.resolveTypeReference(type);
+        if (decl) {
+            const declName = this.convert(decl);
+            return declName;
+        }
+        if (type.name === `Optional`) {
+            return convertJavaOptional(idl.printType(type.typeArguments[0]));
+        }
+        return type.name;
+    }
+    convertTypeParameter(type) {
+        // TODO
+        return type.name;
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLStringType: return 'String';
+            case idl.IDLNumberType: return 'double';
+            case idl.IDLBooleanType: return 'boolean';
+            case idl.IDLUndefinedType: return 'Ark_Undefined';
+            case idl.IDLI8Type: return 'byte';
+            case idl.IDLU8Type: return 'byte';
+            case idl.IDLI16Type: return 'short';
+            case idl.IDLU16Type: return 'short';
+            case idl.IDLI32Type: return 'int';
+            case idl.IDLU32Type: return 'int';
+            case idl.IDLI64Type: return 'long';
+            case idl.IDLU64Type: return 'long';
+            case idl.IDLF32Type: return 'float';
+            case idl.IDLF64Type: return 'double';
+            case idl.IDLPointerType: return 'long';
+            case idl.IDLVoidType: return 'void';
+            case idl.IDLDate: return 'Date';
+            case idl.IDLBufferType: return 'byte[]';
+        }
+        throw new Error(`Unsupported IDL primitive ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    maybeConvertPrimitiveType(javaType) {
+        if (this.javaPrimitiveToReferenceTypeMap.has(javaType)) {
+            return this.javaPrimitiveToReferenceTypeMap.get(javaType);
+        }
+        return javaType;
+    }
+    mapTypeName(name) {
+        switch (name) {
+            case 'KPointer': return 'long';
+            case 'KBoolean': return 'boolean';
+            case 'KUInt': return 'int';
+            case 'int32':
+            case 'KInt': return 'int';
+            case 'int64':
+            case 'KLong': return 'long';
+            case 'float32':
+            case 'KFloat': return 'float';
+            case 'KUint8ArrayPtr': return 'byte[]';
+            case 'KInt32ArrayPtr': return 'int[]';
+            case 'KFloat32ArrayPtr': return 'float[]';
+            // case 'ArrayBuffer': return 'byte[]'
+            case 'KStringPtr': return 'String';
+            case 'string': return 'String';
+        }
+        return name;
+    }
+}
+class JavaIdlNodeToSolidStringConvertor extends JavaTypeNameConvertor {
+    constructor() {
+        super(...arguments);
+        this.solidConvertor = lazy(() => this);
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            const javaTypeSolid = convertType(this, type.elementType[0]);
+            return `Array_${javaTypeSolid}`;
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            const javaTypeSolids = type.elementType.slice(0, 2).map(it => convertType(this, it)).map(this.maybeConvertPrimitiveType, this);
+            return `Map_${javaTypeSolids[0]}_${javaTypeSolids[1]}`;
+        }
+        throw new Error(`IDL type ${idl.DebugUtils.debugPrintType(type)} not supported`);
+    }
+}
+//# sourceMappingURL=JavaConvertors.js.map

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

@@ -0,0 +1,27 @@
+import * as idl from '../../idl';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+export declare class TSTypeNameConvertor implements NodeConvertor<string>, IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    convert(node: idl.IDLNode): string;
+    convertNamespace(node: idl.IDLNamespace): string;
+    convertInterface(node: idl.IDLInterface): string;
+    convertEnum(node: idl.IDLEnum): string;
+    convertTypedef(node: idl.IDLTypedef): string;
+    convertCallback(node: idl.IDLCallback): string;
+    convertMethod(node: idl.IDLMethod): string;
+    convertConstant(node: idl.IDLConstant): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(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 mapFunctionType(typeArgs: string[]): string;
+}
+//# sourceMappingURL=TSConvertors.d.ts.map