@idlizer/core 2.0.17 → 2.0.20

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

@@ -0,0 +1,274 @@
+/*
+ * 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 { generatorConfiguration } from '../../config';
+import * as idl from '../../idl';
+import { qualifiedName } from '../../peer-generation/idl/common';
+import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
+import { capitalize } from '../../util';
+import { maybeTransformManagedCallback } from '../ArgConvertors';
+import { convertNode, convertType } from '../nameConvertor';
+export class InteropConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+    make(text, noPrefix = false) {
+        return { text, noPrefix };
+    }
+    convertNode(node) {
+        return convertNode(this, node);
+    }
+    convertNamespace(node) {
+        throw new Error("Internal error: namespaces are not allowed on the interop layer");
+    }
+    convertInterface(node) {
+        switch (node.subkind) {
+            case idl.IDLInterfaceSubkind.AnonymousInterface:
+                return node.name
+                    ? this.make(node.name)
+                    : this.make(this.computeTargetTypeLiteralName(node), true);
+            case idl.IDLInterfaceSubkind.Interface:
+            case idl.IDLInterfaceSubkind.Class:
+                if (idl.hasExtAttribute(node, idl.IDLExtendedAttributes.Predefined)) {
+                    return this.make(node.name, true);
+                }
+                return this.make(node.name);
+            case idl.IDLInterfaceSubkind.Tuple:
+                return node.name
+                    ? this.make(node.name)
+                    : this.make(`Tuple_${node.properties.map(it => this.convertNode(idl.maybeOptional(it.type, it.isOptional)).text).join("_")}`, true);
+        }
+    }
+    convertEnum(node) {
+        return this.make(this.enumName(node));
+    }
+    convertTypedef(node) {
+        return this.make(node.name);
+    }
+    convertCallback(node) {
+        return this.make(generatorConfiguration().param("LibraryPrefix") + node.name, true);
+    }
+    convertMethod(node) {
+        return this.make(node.name);
+    }
+    convertConstant(node) {
+        return this.make(node.name);
+    }
+    /////////////////////////////////////////////////////////////////////////////////////////
+    convertOptional(type) {
+        return this.convertNode(type.type);
+    }
+    convertUnion(type) {
+        return this.make(type.name, false);
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isPromise(type)) {
+            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`);
+        }
+        if (idl.IDLContainerUtils.isSequence(type)) {
+            if (type.elementType[0] === idl.IDLU8Type) {
+                return this.make(`uint8_t*`, true);
+            }
+            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, true);
+        }
+        if (idl.IDLContainerUtils.isRecord(type)) {
+            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, true);
+        }
+        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    convertImport(type, _) {
+        return this.make(idl.IDLCustomObjectType.name);
+    }
+    convertTypeReference(type) {
+        var _a;
+        const refName = type.name;
+        switch (refName) {
+            case "object":
+            case "Object":
+                return this.make('CustomObject');
+        }
+        if (generatorConfiguration().paramArray("knownParameterized").includes(refName)) {
+            return this.make('CustomObject');
+        }
+        let decl = this.resolver.toDeclaration(type);
+        if (idl.isCallback(decl)) {
+            decl = (_a = maybeTransformManagedCallback(decl)) !== null && _a !== void 0 ? _a : decl;
+        }
+        if (idl.isType(decl)) {
+            if (idl.isReferenceType(decl)) {
+                return this.make(`${capitalize(decl.name)}`);
+            }
+            return this.convertNode(decl);
+        }
+        let res = this.convertNode(decl);
+        if (type.name === "Optional")
+            res = this.make("Opt_" + res.text, true);
+        return res;
+    }
+    convertTypeParameter(type) {
+        return this.make('CustomObject');
+    }
+    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.IDLPointerType: return this.make('NativePointer');
+            case idl.IDLUnknownType:
+            case idl.IDLCustomObjectType:
+            case idl.IDLAnyType: return this.make(`CustomObject`);
+            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');
+        }
+        throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    enumName(target) {
+        return qualifiedName(target, "_");
+    }
+    computeTargetTypeLiteralName(decl) {
+        const map = new Map();
+        for (const prop of decl.properties) {
+            const type = this.convertNode(prop.type);
+            const values = map.has(type.text) ? map.get(type.text) : [];
+            values.push(prop.name);
+            map.set(type.text, values);
+        }
+        const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
+        return `Literal_${names.join('_')}`;
+    }
+}
+export class InteropNameConvertor {
+    constructor(resolver) {
+        this.resolver = resolver;
+        this.interopConvertor = new InteropConvertor(resolver);
+    }
+    convert(node) {
+        return this.interopConvertor.convertNode(node).text;
+    }
+}
+export class InteropReturnTypeConvertor {
+    isVoid(method) {
+        return this.convert(method.returnType) === idl.IDLVoidType.name;
+    }
+    convert(type) {
+        return convertType(this, type);
+    }
+    convertContainer(type) {
+        if (idl.IDLContainerUtils.isSequence(type) || idl.IDLContainerUtils.isPromise(type)) {
+            // TODO return array by some way
+            return "void";
+        }
+        else
+            return PrimitiveTypesInstance.NativePointer.getText();
+    }
+    convertImport(type, importClause) {
+        throw new Error(`Cannot pass import type ${type.name} through interop`);
+    }
+    convertOptional(type) {
+        return this.convert(type.type);
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI8Type:
+            case idl.IDLU8Type:
+            case idl.IDLI16Type:
+            case idl.IDLU16Type:
+            case idl.IDLI32Type:
+            case idl.IDLU32Type:
+            case idl.IDLI64Type:
+            case idl.IDLU64Type:
+            case idl.IDLF16Type:
+            case idl.IDLF32Type:
+            case idl.IDLF64Type:
+            case idl.IDLNumberType: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLBooleanType: return PrimitiveTypesInstance.Boolean.getText();
+            case idl.IDLAnyType:
+            case idl.IDLBufferType:
+            case idl.IDLStringType:
+            case idl.IDLThisType:
+            case idl.IDLUndefinedType:
+            case idl.IDLUnknownType:
+            case idl.IDLVoidType: return idl.IDLVoidType.name;
+            case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeParameter(type) {
+        return idl.IDLVoidType.name;
+    }
+    convertTypeReference(type) {
+        if (type.name.endsWith("Attribute"))
+            return idl.IDLVoidType.name;
+        return PrimitiveTypesInstance.NativePointer.getText();
+    }
+    convertUnion(type) {
+        return PrimitiveTypesInstance.NativePointer.getText();
+    }
+}
+export class InteropArgConvertor {
+    convert(type) {
+        return convertType(this, type);
+    }
+    convertContainer(type) {
+        throw new Error(`Cannot pass container types through interop`);
+    }
+    convertImport(type, importClause) {
+        throw new Error(`Cannot pass import types through interop`);
+    }
+    convertOptional(type) {
+        return "KNativePointer";
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLI32Type: return "KInt";
+            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.IDLDate: return 'KLong';
+            case idl.IDLUndefinedType:
+            case idl.IDLVoidType: return PrimitiveTypesInstance.NativePointer.getText();
+            case idl.IDLPointerType: return "KPointer"; //PrimitiveType.NativePointer.getText()
+        }
+        throw new Error(`Cannot pass primitive type ${type.name} through interop`);
+    }
+    convertTypeParameter(type) {
+        throw new Error("Cannot pass type parameters through interop");
+    }
+    convertTypeReference(type) {
+        throw new Error(`Cannot pass type references through interop`);
+    }
+    convertUnion(type) {
+        throw new Error("Cannot pass union types through interop");
+    }
+}
+//# sourceMappingURL=InteropConvertors.js.map

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

@@ -0,0 +1,36 @@
+import * as idl from '../../idl';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor } from '../nameConvertor';
+import { InteropArgConvertor } from './InteropConvertors';
+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 declare class JavaInteropArgConvertor extends InteropArgConvertor {
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+}
+export {};
+//# sourceMappingURL=JavaConvertors.d.ts.map

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

@@ -0,0 +1,186 @@
+/*
+ * 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';
+import { InteropArgConvertor } from './InteropConvertors';
+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`);
+    }
+}
+export class JavaInteropArgConvertor extends InteropArgConvertor {
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLNumberType: return "double";
+            case idl.IDLLengthType: return "String";
+            case idl.IDLBooleanType: return "boolean";
+        }
+        return super.convertPrimitiveType(type);
+    }
+}
+//# 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