@idlizer/core 2.0.17 → 2.0.20

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

@@ -19,7 +19,7 @@ import { RuntimeType } from "./common";
 import { generatorTypePrefix } from "../config";
 import { hashCodeFromString, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
-import { InteropNameConvertor } from "./InteropConvertor";
+import { InteropNameConvertor } from "./convertors/InteropConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { CppInteropConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";

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;
+    writeExpressionStatements(statements: LanguageExpression[]): void;
     writeStaticBlock(op: (writer: this) => void): void;
     makeRef(type: idl.IDLType, _options?: MakeRefOptions): idl.IDLType;
     makeThis(): LanguageExpression;

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

@@ -437,6 +437,9 @@ export class LanguageWriter {
     writeExpressionStatement(smth) {
         this.writeStatement(new ExpressionStatement(smth));
     }
+    writeExpressionStatements(statements) {
+        statements.forEach(it => this.writeExpressionStatement(it));
+    }
     writeStaticBlock(op) {
         this.print("static {");
         this.pushIndent();

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

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

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

@@ -0,0 +1,164 @@
+/*
+ * 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';
+import { InteropArgConvertor } from './InteropConvertors';
+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);
+    }
+}
+export class CJInteropArgConvertor extends InteropArgConvertor {
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLNumberType: return "Float64";
+            case idl.IDLLengthType: return "Ark_Length";
+        }
+        return super.convertPrimitiveType(type);
+    }
+}
+//# sourceMappingURL=CJConvertors.js.map

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

@@ -1,8 +1,14 @@
 import * as idl from '../../idl';
 import { IdlNameConvertor } from "../nameConvertor";
-import { InteropConvertor } from '../InteropConvertor';
+import { InteropConvertor } from './InteropConvertors';
+import { InteropArgConvertor } from './InteropConvertors';
 export declare class CppInteropConvertor extends InteropConvertor implements IdlNameConvertor {
     private unwrap;
     convert(node: idl.IDLNode): string;
 }
+export declare class CppInteropArgConvertor extends InteropArgConvertor {
+    static INSTANCE: CppInteropArgConvertor;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+}
 //# sourceMappingURL=CppConvertors.d.ts.map

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

@@ -14,16 +14,18 @@
  */
 import * as idl from '../../idl';
 import { generatorConfiguration } from "../../config";
-import { InteropConvertor } from '../InteropConvertor';
+import { InteropConvertor } from './InteropConvertors';
+import { PrimitiveTypesInstance } from '../../peer-generation/PrimitiveType';
+import { InteropArgConvertor } from './InteropConvertors';
 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");
         // TODO remove this ugly hack for CustomObject's
         const convertedToCustomObject = result.text === idl.IDLCustomObjectType.name;
@@ -34,4 +36,23 @@ export class CppInteropConvertor extends InteropConvertor {
         return this.unwrap(node, this.convertNode(node));
     }
 }
+export class CppInteropArgConvertor extends InteropArgConvertor {
+    convertOptional(type) {
+        return PrimitiveTypesInstance.NativePointer.getText();
+    }
+    convertPrimitiveType(type) {
+        switch (type) {
+            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.IDLFunctionType: return PrimitiveTypesInstance.Int32.getText();
+            case idl.IDLDate: return PrimitiveTypesInstance.Int64.getText();
+            case idl.IDLPointerType: return PrimitiveTypesInstance.NativePointer.getText();
+        }
+        return super.convertPrimitiveType(type);
+    }
+}
+CppInteropArgConvertor.INSTANCE = new CppInteropArgConvertor();
 //# sourceMappingURL=CppConvertors.js.map

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/InteropConvertors.d.ts

@@ -0,0 +1,58 @@
+import * as idl from '../../idl';
+import { PeerMethod } from '../../peer-generation/PeerMethod';
+import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { IdlNameConvertor, NodeConvertor, TypeConvertor } from '../nameConvertor';
+export interface ConvertResult {
+    text: string;
+    noPrefix: boolean;
+}
+export declare class InteropConvertor implements NodeConvertor<ConvertResult> {
+    protected resolver: ReferenceResolver;
+    constructor(resolver: ReferenceResolver);
+    private make;
+    convertNode(node: idl.IDLNode): ConvertResult;
+    convertNamespace(node: idl.IDLNamespace): ConvertResult;
+    convertInterface(node: idl.IDLInterface): ConvertResult;
+    convertEnum(node: idl.IDLEnum): ConvertResult;
+    convertTypedef(node: idl.IDLTypedef): ConvertResult;
+    convertCallback(node: idl.IDLCallback): ConvertResult;
+    convertMethod(node: idl.IDLMethod): ConvertResult;
+    convertConstant(node: idl.IDLConstant): ConvertResult;
+    convertOptional(type: idl.IDLOptionalType): ConvertResult;
+    convertUnion(type: idl.IDLUnionType): ConvertResult;
+    convertContainer(type: idl.IDLContainerType): ConvertResult;
+    convertImport(type: idl.IDLReferenceType, _: string): ConvertResult;
+    convertTypeReference(type: idl.IDLReferenceType): ConvertResult;
+    convertTypeParameter(type: idl.IDLTypeParameterType): ConvertResult;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
+    private enumName;
+    private computeTargetTypeLiteralName;
+}
+export declare class InteropNameConvertor implements IdlNameConvertor {
+    protected resolver: ReferenceResolver;
+    private readonly interopConvertor;
+    constructor(resolver: ReferenceResolver);
+    convert(node: idl.IDLNode): string;
+}
+export declare class InteropReturnTypeConvertor implements TypeConvertor<string> {
+    isVoid(method: PeerMethod): boolean;
+    convert(type: idl.IDLType): string;
+    convertContainer(type: idl.IDLContainerType): string;
+    convertImport(type: idl.IDLReferenceType, importClause: string): string;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertUnion(type: idl.IDLUnionType): 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;
+    convertOptional(type: idl.IDLOptionalType): string;
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
+    convertTypeParameter(type: idl.IDLTypeParameterType): string;
+    convertTypeReference(type: idl.IDLReferenceType): string;
+    convertUnion(type: idl.IDLUnionType): string;
+}
+//# sourceMappingURL=InteropConvertors.d.ts.map