@idlizer/core 2.0.15

package/build/lib/src/LanguageWriters/writers/ETSLanguageWriter.js

@@ -0,0 +1,329 @@
+/*
+ * 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 { IndentedPrinter } from "../../IndentedPrinter";
+import { LambdaExpression, MethodModifier } from "../LanguageWriter";
+import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
+import { getExtAttribute, IDLI32Type, IDLThisType } from '../../idl';
+import { AggregateConvertor, ArrayConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor, OptionConvertor, UnionConvertor } from "../ArgConvertors";
+import * as idl from '../../idl';
+import { convertDeclaration } from "../nameConvertor";
+import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
+import { Language } from "../../Language";
+import { RuntimeType } from "../common";
+import { throwException } from "../../util";
+////////////////////////////////////////////////////////////////
+//                         STATEMENTS                         //
+////////////////////////////////////////////////////////////////
+export class EtsAssignStatement {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true) {
+        this.variableName = variableName;
+        this.type = type;
+        this.expression = expression;
+        this.isDeclared = isDeclared;
+        this.isConst = isConst;
+    }
+    write(writer) {
+        if (this.isDeclared) {
+            const typeClause = this.type !== undefined ? `: ${writer.getNodeName(this.type)}` : '';
+            const maybeAssign = this.expression !== undefined ? " = " : "";
+            const initValue = this.expression !== undefined ? this.expression : writer.makeString("");
+            writer.print(`${this.isConst ? "const" : "let"} ${this.variableName} ${typeClause}${maybeAssign}${initValue.asString()}`);
+        }
+        else {
+            writer.print(`${this.variableName} = ${this.expression.asString()}`);
+        }
+    }
+}
+class ArkTSMapForEachStatement {
+    constructor(map, key, value, op) {
+        this.map = map;
+        this.key = key;
+        this.value = value;
+        this.op = op;
+    }
+    write(writer) {
+        writer.print(`// TODO: map serialization not implemented`);
+    }
+}
+export class ArkTSEnumEntityStatement {
+    constructor(enumEntity, isExport) {
+        this.enumEntity = enumEntity;
+        this.isExport = isExport;
+    }
+    write(writer) {
+        const enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
+        const members = this.enumEntity.elements
+            .flatMap((member, index) => {
+            var _a;
+            const initText = (_a = member.initializer) !== null && _a !== void 0 ? _a : index;
+            const isTypeString = typeof initText !== "number";
+            const originalName = getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
+            const res = [{
+                    name: member.name,
+                    alias: undefined,
+                    stringId: isTypeString ? initText : undefined,
+                    numberId: initText
+                }];
+            if (originalName !== undefined) {
+                res.push({
+                    name: originalName,
+                    alias: undefined,
+                    stringId: isTypeString ? initText : undefined,
+                    numberId: initText
+                });
+                //TODO: enums do not support member aliases
+                // res.push({
+                //     name: originalName,
+                //     alias: member.name,
+                //     stringId: undefined,
+                //     numberId: initText as number
+                // })
+            }
+            return res;
+        });
+        writer.writeEnum(enumName, members);
+    }
+}
+export class ETSLambdaExpression extends LambdaExpression {
+    constructor(writer, convertor, signature, resolver, body) {
+        super(writer, signature, resolver, body);
+        this.convertor = convertor;
+    }
+    get statementHasSemicolon() {
+        return false;
+    }
+    asString() {
+        const params = this.signature.args.map((it, i) => {
+            const maybeOptional = idl.isOptionalType(it) ? "?" : "";
+            return `${this.signature.argName(i)}${maybeOptional}: ${this.convertor.convert(it)}`;
+        });
+        // Workaround to fix ArkTS error: SyntaxError: Unexpected token, arrow (=>)
+        // Issue: https://rnd-gitlab-msc.huawei.com/rus-os-team/virtual-machines-and-tools/panda/-/issues/21333
+        let isRetTypeCallback = idl.isCallback(this.signature.returnType);
+        if (idl.isReferenceType(this.signature.returnType)) {
+            const resolved = this.resolver.resolveTypeReference(idl.createReferenceType(this.signature.returnType.name, undefined, this.signature.returnType));
+            isRetTypeCallback = resolved !== undefined && idl.isCallback(resolved);
+        }
+        return `(${params.join(", ")})${isRetTypeCallback
+            ? "" : `:${this.convertor.convert(this.signature.returnType)}`} => { ${this.bodyAsString()} }`;
+    }
+}
+////////////////////////////////////////////////////////////////
+//                           UTILS                            //
+////////////////////////////////////////////////////////////////
+export function generateTypeCheckerName(typeName) {
+    typeName = typeName.replaceAll('[]', 'BracketsArray')
+        .replaceAll('.', ''); // Todo: hack for namespaces
+    return `is${typeName.replaceAll('[]', 'Brackets')}`;
+}
+export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
+    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
+    ]);
+}
+////////////////////////////////////////////////////////////////
+//                           WRITER                           //
+////////////////////////////////////////////////////////////////
+export class ETSLanguageWriter extends TSLanguageWriter {
+    constructor(printer, resolver, typeConvertor, arrayConvertor) {
+        super(printer, resolver, typeConvertor, Language.ARKTS);
+        this.arrayConvertor = arrayConvertor;
+    }
+    fork(options) {
+        var _a;
+        return new ETSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
+    }
+    writeNativeMethodDeclaration(name, signature) {
+        if (signature.returnType === IDLThisType) {
+            throw new Error('static method can not return this!');
+        }
+        this.writeMethodDeclaration(name, signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
+    }
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
+        return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst);
+    }
+    makeLambda(signature, body) {
+        return new ETSLambdaExpression(this, this.typeConvertor, signature, this.resolver, body);
+    }
+    makeMapForEach(map, key, value, op) {
+        return new ArkTSMapForEachStatement(map, key, value, op);
+    }
+    makeMapSize(map) {
+        return this.makeString(`${super.makeMapSize(map).asString()} as int32`); // TODO: cast really needed?
+    }
+    get supportedModifiers() {
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.NATIVE, MethodModifier.STATIC];
+    }
+    makeUnsafeCast(convertor, param) {
+        if (idl.isEnum(convertor.idlType) && !param.endsWith(".value")) {
+            const isStringEnum = idl.isStringEnum(convertor.idlType);
+            return `(${param} as ${this.typeConvertor.convert(convertor.idlType)}).${isStringEnum ? 'ordinal' : 'value'}`;
+        }
+        return super.makeUnsafeCast(convertor, param);
+    }
+    runtimeType(param, valueType, value) {
+        super.runtimeType(param, valueType, value);
+    }
+    makeUnionVariantCast(value, type, convertor, index) {
+        return this.makeString(`${value} as ${type}`);
+    }
+    enumFromOrdinal(value, enumEntry) {
+        const enumName = this.getNodeName(enumEntry);
+        return this.makeString(`${value.asString()} as ${enumName}`);
+    }
+    ordinalFromEnum(value, _) {
+        return this.makeCast(this.makeString(`${value.asString()}`), IDLI32Type);
+    }
+    makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
+        if (convertor instanceof AggregateConvertor
+            || convertor instanceof InterfaceConvertor
+            || convertor instanceof MaterializedClassConvertor
+            || convertor instanceof CustomTypeConvertor) {
+            return this.instanceOf(convertor, value, duplicates);
+        }
+        return this.makeString(`${value} instanceof ${convertor.targetType(this)}`);
+    }
+    makeValueFromOption(value, destinationConvertor) {
+        if (idl.isEnum(this.resolver.toDeclaration(destinationConvertor.nativeType()))) {
+            return this.makeCast(this.makeString(value), destinationConvertor.idlType);
+        }
+        return super.makeValueFromOption(value, destinationConvertor);
+    }
+    makeCallIsResource(value) {
+        return this.makeString(`isResource(${value})`);
+    }
+    makeEnumEntity(enumEntity, isExport) {
+        return new ArkTSEnumEntityStatement(enumEntity, isExport);
+    }
+    getObjectAccessor(convertor, value, args) {
+        return super.getObjectAccessor(convertor, value, args);
+    }
+    writeMethodCall(receiver, method, params, nullable = false) {
+        // ArkTS does not support - 'this.?'
+        super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
+    }
+    writeProperty(propName, propType) {
+        throw new Error("writeProperty for ArkTS is not implemented yet.");
+    }
+    makeEnumCast(value, _unsafe, convertor) {
+        if (convertor === undefined) {
+            throwException(`The makeEnumCast function required EnumConvertor`);
+        }
+        const decl = this.resolver.toDeclaration(convertor.nativeType());
+        if (!idl.isEnum(decl)) {
+            throwException(`Declaration type must be Enum`);
+        }
+        return this.makeCast(this.makeString(`${value}${idl.isStringEnum(decl) ? "" : ".valueOf()"}`), IDLI32Type).asString();
+    }
+    makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
+        if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
+            return this.instanceOf(convertor, valueName);
+        }
+        // TODO: in ArkTS SerializerBase.runtimeType returns RuntimeType.OBJECT for enum type and not RuntimeType.NUMBER as in TS
+        if (convertor instanceof UnionConvertor || convertor instanceof OptionConvertor) {
+            // Unwrapping of type
+            const idlType = convertor instanceof UnionConvertor
+                ? convertor.nativeType().types[runtimeTypeIndex]
+                : idl.maybeUnwrapOptionalType(convertor.nativeType());
+            if (idlType !== undefined && idl.isReferenceType(idlType)) {
+                const resolved = this.resolver.resolveTypeReference(idl.createReferenceType(idlType.name, undefined, idlType));
+                type = resolved != undefined && idl.isEnum(resolved) ? RuntimeType[RuntimeType.OBJECT] : type;
+            }
+        }
+        return super.makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex);
+    }
+    makeCastCustomObject(customName, isGenericType) {
+        if (isGenericType) {
+            return this.makeCast(this.makeString(customName), idl.IDLObjectType);
+        }
+        return super.makeCastCustomObject(customName, isGenericType);
+    }
+    makeHasOwnProperty(value, valueTypeName, property, propertyTypeName) {
+        return this.makeNaryOp("&&", [
+            this.makeString(`${value} instanceof ${valueTypeName}`),
+            this.makeString(`isInstanceOf("${propertyTypeName}", ${value}.${property})`)
+        ]);
+    }
+    makeEquals(args) {
+        // TODO: Error elimination: 'TypeError: Both operands have to be reference types'
+        // the '==' operator must be used when one of the operands is a reference
+        return super.makeNaryOp('==', args);
+    }
+    makeDiscriminatorConvertor(convertor, value, index) {
+        return this.instanceOf(convertor, value);
+        // Or this ????????
+        // return this.discriminatorFromExpressions(value, RuntimeType.OBJECT, [
+        //     makeEnumTypeCheckerCall(value, this.getNodeName(convertor.idlType), this)
+        // ])
+    }
+    castToInt(value, bitness) {
+        return `${value} as int32`; // FIXME: is there int8 in ARKTS?
+    }
+    castToBoolean(value) { return `${value} ? 1 : 0`; }
+    instanceOf(convertor, value, duplicateMembers) {
+        if (convertor instanceof CustomTypeConvertor) {
+            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), [], duplicateMembers, this);
+        }
+        if (convertor instanceof InterfaceConvertor || convertor instanceof MaterializedClassConvertor) {
+            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), convertor.declaration.properties.filter(it => !it.isStatic).map(it => it.name), duplicateMembers, this);
+        }
+        if (convertor instanceof AggregateConvertor) {
+            return makeInterfaceTypeCheckerCall(value, convertor.aliasName !== undefined ? convertor.aliasName : this.getNodeName(convertor.idlType), convertor.members.map(it => it[0]), duplicateMembers, this);
+        }
+        if (convertor instanceof ArrayConvertor) {
+            return makeArrayTypeCheckCall(value, this.arrayConvertor.convert(convertor.idlType), this);
+        }
+        if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
+            return makeEnumTypeCheckerCall(value, this.getNodeName(convertor.idlType), this);
+        }
+        return super.instanceOf(convertor, value, duplicateMembers);
+    }
+    typeInstanceOf(type, value, members) {
+        if (!members || members.length === 0) {
+            throw new Error("At least one member needs to provided to pass it to TypeChecker!");
+        }
+        const prop = members[0];
+        // Use the same typeInstanceOf<T>(...) method to compile the ETS code by two compilers ArkTS and TS
+        return this.makeString(`TypeChecker.typeInstanceOf<${this.getNodeName(type)}>(value, "${prop}")`);
+    }
+    makeTypeCast(value, type, options) {
+        return this.makeString(`TypeChecker.typeCast<${this.getNodeName(type)}>(value)`);
+    }
+    makeCast(value, type, options) {
+        var _a;
+        return new TSCastExpression(value, `${this.getNodeName(type)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+    }
+}
+const builtInInterfaceTypes = new Map([
+    ["Resource",
+        (writer, value) => writer.makeCallIsResource(value)],
+    ["Object",
+        (writer, value) => writer.makeCallIsObject(value)],
+    ["ArrayBuffer",
+        (writer, value) => writer.makeCallIsArrayBuffer(value)]
+]);
+function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
+    if (builtInInterfaceTypes.has(interfaceName)) {
+        return builtInInterfaceTypes.get(interfaceName)(writer, valueAccessor);
+    }
+    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
+        ...allFields.map(it => {
+            return writer.makeString(duplicates.has(it) ? "true" : "false");
+        })
+    ]);
+}
+export function makeEnumTypeCheckerCall(valueAccessor, enumName, writer) {
+    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(enumName), [writer.makeString(valueAccessor)]);
+}
+//# sourceMappingURL=ETSLanguageWriter.js.map

package/build/lib/src/LanguageWriters/writers/JavaLanguageWriter.d.ts

@@ -0,0 +1,83 @@
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { CLikeLanguageWriter } from "./CLikeLanguageWriter";
+import * as idl from '../../idl';
+import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
+import { IdlNameConvertor } from "../nameConvertor";
+import { RuntimeType } from "../common";
+import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class JavaCheckDefinedExpression implements LanguageExpression {
+    private value;
+    constructor(value: string);
+    asString(): string;
+}
+export declare class JavaCastExpression implements LanguageExpression {
+    value: LanguageExpression;
+    type: string;
+    private unsafe;
+    constructor(value: LanguageExpression, type: string, unsafe?: boolean);
+    asString(): string;
+}
+export declare class JavaAssignStatement extends AssignStatement {
+    variableName: string;
+    type: idl.IDLType | undefined;
+    expression: LanguageExpression;
+    isDeclared: boolean;
+    protected isConst: boolean;
+    constructor(variableName: string, type: idl.IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean);
+    write(writer: LanguageWriter): void;
+}
+export declare class JavaLanguageWriter extends CLikeLanguageWriter {
+    protected typeConvertor: IdlNameConvertor;
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor);
+    getNodeName(type: idl.IDLNode): string;
+    fork(options?: {
+        resolver?: ReferenceResolver;
+    }): LanguageWriter;
+    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[]): void;
+    writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
+    writeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    writeProperty(propName: string, propType: idl.IDLType): void;
+    makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
+    makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
+    makeReturn(expr: LanguageExpression): LanguageStatement;
+    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
+    makeDefinedCheck(value: string): LanguageExpression;
+    makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapSize(map: string): LanguageExpression;
+    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeStatement(expr: LanguageExpression): LanguageStatement;
+    makeUnionSelector(value: string, valueType: string): LanguageStatement;
+    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, _type: string, convertorIndex: number): LanguageExpression;
+    makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
+    makeUnionTypeDefaultInitializer(): LanguageExpression;
+    writePrintLog(message: string): void;
+    mapIDLContainerType(type: idl.IDLContainerType): string;
+    applyToObject(p: BaseArgConvertor, param: string, value: string, args?: ObjectArgs): LanguageStatement;
+    getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
+    makeUndefined(): LanguageExpression;
+    makeRuntimeType(rt: RuntimeType): LanguageExpression;
+    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
+    getTagType(): idl.IDLType;
+    getRuntimeType(): idl.IDLType;
+    makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
+    get supportedModifiers(): MethodModifier[];
+    get supportedFieldModifiers(): FieldModifier[];
+    makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
+    makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
+    makeMapInit(type: idl.IDLType): LanguageExpression;
+    makeTupleAccess(value: string, index: number): LanguageExpression;
+    enumFromOrdinal(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    makeValueFromOption(value: string): LanguageExpression;
+    runtimeType(param: ArgConvertor, valueType: string, value: string): void;
+    makeEnumCast(enumName: string, _unsafe: boolean, _convertor: ArgConvertor | undefined): string;
+    castToBoolean(value: string): string;
+    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
+}
+//# sourceMappingURL=JavaLanguageWriter.d.ts.map