@idlizer/core 2.0.15

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

@@ -0,0 +1,275 @@
+/*
+ * 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 { Language } from '../../Language';
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { AssignStatement, CheckOptionalStatement, FieldModifier, LambdaExpression, MethodModifier, } from "../LanguageWriter";
+import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
+import * as idl from '../../idl';
+import { RuntimeType } from "../common";
+////////////////////////////////////////////////////////////////
+//                        EXPRESSIONS                         //
+////////////////////////////////////////////////////////////////
+class JavaLambdaExpression extends LambdaExpression {
+    constructor(writer, signature, resolver, body) {
+        super(writer, signature, resolver, body);
+    }
+    get statementHasSemicolon() {
+        return true;
+    }
+    asString() {
+        const params = this.signature.args.map((it, i) => `${idl.forceAsNamedNode(it).name} ${this.signature.argName(i)}`);
+        return `(${params.join(", ")}) -> { ${this.bodyAsString()} }`;
+    }
+}
+export class JavaCheckDefinedExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    asString() {
+        return `${this.value} != null`;
+    }
+}
+export class JavaCastExpression {
+    constructor(value, type, unsafe = false) {
+        this.value = value;
+        this.type = type;
+        this.unsafe = unsafe;
+    }
+    asString() {
+        return `(${this.type})(${this.value.asString()})`;
+    }
+}
+////////////////////////////////////////////////////////////////
+//                         STATEMENTS                         //
+////////////////////////////////////////////////////////////////
+export class JavaAssignStatement extends AssignStatement {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true) {
+        super(variableName, type, expression, isDeclared, isConst);
+        this.variableName = variableName;
+        this.type = type;
+        this.expression = expression;
+        this.isDeclared = isDeclared;
+        this.isConst = isConst;
+    }
+    write(writer) {
+        if (this.isDeclared) {
+            const typeSpec = this.type ? writer.getNodeName(this.type) : "var";
+            writer.print(`${typeSpec} ${this.variableName} = ${this.expression.asString()};`);
+        }
+        else {
+            writer.print(`${this.variableName} = ${this.expression.asString()};`);
+        }
+    }
+}
+class JavaMapForEachStatement {
+    constructor(map, key, value, op) {
+        this.map = map;
+        this.key = key;
+        this.value = value;
+        this.op = op;
+    }
+    write(writer) {
+        const entryVar = `${this.map}Entry`;
+        writer.print(`for (var ${entryVar}: ${this.map}.entrySet()) {`);
+        writer.pushIndent();
+        writer.print(`var ${this.key} = ${entryVar}.getKey();`);
+        writer.print(`var ${this.value} = ${entryVar}.getValue();`);
+        this.op();
+        writer.popIndent();
+        writer.print(`}`);
+    }
+}
+////////////////////////////////////////////////////////////////
+//                           WRITER                           //
+////////////////////////////////////////////////////////////////
+export class JavaLanguageWriter extends CLikeLanguageWriter {
+    constructor(printer, resolver, typeConvertor) {
+        super(printer, resolver, Language.JAVA);
+        this.typeConvertor = typeConvertor;
+    }
+    getNodeName(type) {
+        return this.typeConvertor.convert(type);
+    }
+    fork(options) {
+        var _a;
+        return new JavaLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor);
+    }
+    writeClass(name, op, superClass, interfaces, generics, isDeclared, isExport = true) {
+        let genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(', ')}> ` : ``;
+        let extendsClause = superClass ? ` extends ${superClass}` : '';
+        let implementsClause = interfaces ? ` implements ${interfaces.join(",")}` : '';
+        this.printer.print(`${isExport ? 'public ' : ''}class ${name}${genericsClause}${extendsClause}${implementsClause} {`); // TODO check for multiple classes in file
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeInterface(name, op, superInterfaces) {
+        let extendsClause = superInterfaces ? ` extends ${superInterfaces.join(",")}` : '';
+        this.printer.print(`interface ${name}${extendsClause} {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeMethodCall(receiver, method, params, nullable = false) {
+        if (nullable) {
+            this.printer.print(`if (${receiver} != null) ${receiver}.${method}(${params.join(", ")});`);
+        }
+        else {
+            super.writeMethodCall(receiver, method, params, nullable);
+        }
+    }
+    writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
+        let prefix = this.makeFieldModifiersList(modifiers);
+        this.printer.print(`${prefix} ${(this.getNodeName(type))} ${name}${initExpr ? ` = ${initExpr.asString()}` : ""};`);
+    }
+    writeNativeMethodDeclaration(name, signature) {
+        this.writeMethodDeclaration(name, signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
+    }
+    writeConstructorImplementation(className, signature, op, superCall, modifiers) {
+        this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') : ''} ${className}(${signature.args.map((it, index) => `${this.getNodeName(it)} ${signature.argName(index)}`).join(", ")}) {`);
+        this.pushIndent();
+        if (superCall) {
+            this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")});`);
+        }
+        op(this);
+        this.popIndent();
+        this.printer.print(`}`);
+    }
+    writeProperty(propName, propType) {
+        throw new Error("writeProperty for Java is not implemented yet.");
+    }
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
+        return new JavaAssignStatement(variableName, type, expr, isDeclared, isConst);
+    }
+    makeLambda(signature, body) {
+        return new JavaLambdaExpression(this, signature, this.resolver, body);
+    }
+    makeReturn(expr) {
+        return new CLikeReturnStatement(expr);
+    }
+    makeCheckOptional(optional, doStatement) {
+        return new CheckOptionalStatement("null", optional, doStatement);
+    }
+    makeDefinedCheck(value) {
+        return new JavaCheckDefinedExpression(value);
+    }
+    makeLoop(counter, limit, statement) {
+        return new CLikeLoopStatement(counter, limit, statement);
+    }
+    makeMapForEach(map, key, value, op) {
+        return new JavaMapForEachStatement(map, key, value, op);
+    }
+    makeMapSize(map) {
+        return this.makeString(`${map}.size()`);
+    }
+    makeCast(value, type, options) {
+        var _a;
+        return new JavaCastExpression(value, this.getNodeName(type), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+    }
+    makeStatement(expr) {
+        return new CLikeExpressionStatement(expr);
+    }
+    makeUnionSelector(value, valueType) {
+        return this.makeAssign(valueType, undefined, this.makeMethodCall(value, "getSelector", []), false);
+    }
+    makeUnionVariantCondition(_convertor, _valueName, valueType, _type, convertorIndex) {
+        return this.makeString(`${valueType} == ${convertorIndex}`);
+    }
+    makeUnionVariantCast(value, type, convertor, index) {
+        return this.makeMethodCall(value, `getValue${index}`, []);
+    }
+    makeUnionTypeDefaultInitializer() {
+        return this.makeString("-1");
+    }
+    writePrintLog(message) {
+        this.print(`System.out.println("${message}")`);
+    }
+    mapIDLContainerType(type) {
+        switch (type.containerKind) {
+            case "sequence": return `${this.getNodeName(type.elementType[0])}[]`;
+        }
+        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+    }
+    applyToObject(p, param, value, args) {
+        throw new Error("Method not implemented.");
+    }
+    getObjectAccessor(convertor, value, args) {
+        return value;
+    }
+    makeUndefined() {
+        return this.makeString("null");
+    }
+    makeRuntimeType(rt) {
+        return this.makeString(`RuntimeType.${RuntimeType[rt]}`);
+    }
+    makeRuntimeTypeGetterCall(value) {
+        return this.makeMethodCall("Ark_Object", "getRuntimeType", [this.makeString(value)]);
+    }
+    makeMapInsert(keyAccessor, key, valueAccessor, value) {
+        throw new Error("Method not implemented.");
+    }
+    getTagType() {
+        throw new Error("Method not implemented.");
+    }
+    getRuntimeType() {
+        throw new Error("Method not implemented.");
+    }
+    makeTupleAssign(receiver, tupleFields) {
+        throw new Error("Method not implemented.");
+    }
+    get supportedModifiers() {
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.STATIC, MethodModifier.NATIVE];
+    }
+    get supportedFieldModifiers() {
+        return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.STATIC, FieldModifier.FINAL];
+    }
+    makeArrayInit(type, size) {
+        return this.makeString(`new ${this.getNodeName(type.elementType[0])}[${size !== null && size !== void 0 ? size : 0}]`);
+    }
+    makeClassInit(type, paramenters) {
+        throw new Error("Method not implemented.");
+    }
+    makeMapInit(type) {
+        throw new Error("Method not implemented.");
+    }
+    makeTupleAccess(value, index) {
+        return this.makeString(`${value}.value${index}`);
+    }
+    enumFromOrdinal(value, _) {
+        throw new Error("Method not implemented.");
+    }
+    ordinalFromEnum(value, _) {
+        return this.makeString(`${value.asString()}.value`);
+    }
+    makeValueFromOption(value) {
+        return this.makeString(`${value}`);
+    }
+    runtimeType(param, valueType, value) {
+        this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
+    }
+    makeEnumCast(enumName, _unsafe, _convertor) {
+        return `${enumName}.getIntValue()`;
+    }
+    castToBoolean(value) { return value; }
+    makeLengthSerializer(serializer, value) {
+        return this.makeBlock([
+            this.makeStatement(this.makeMethodCall(serializer, "writeInt8", [this.makeRuntimeType(RuntimeType.STRING)])),
+            this.makeStatement(this.makeMethodCall(serializer, "writeString", [this.makeString(`${value}.value`)]))
+        ], false);
+    }
+}
+//# sourceMappingURL=JavaLanguageWriter.js.map

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

@@ -0,0 +1,93 @@
+import * as idl from '../../idl';
+import { Language } from '../../Language';
+import { IndentedPrinter } from "../../IndentedPrinter";
+import { FieldModifier, LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs, ReturnStatement } from "../LanguageWriter";
+import { ArgConvertor } from "../ArgConvertors";
+import { IdlNameConvertor } from "../nameConvertor";
+import { RuntimeType } from "../common";
+import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class TSLambdaExpression extends LambdaExpression {
+    private convertor;
+    constructor(writer: LanguageWriter, convertor: IdlNameConvertor, signature: MethodSignature, resolver: ReferenceResolver, body?: LanguageStatement[]);
+    protected get statementHasSemicolon(): boolean;
+    asString(): string;
+}
+export declare class TSCastExpression implements LanguageExpression {
+    value: LanguageExpression;
+    type: string;
+    private unsafe;
+    constructor(value: LanguageExpression, type: string, unsafe?: boolean);
+    asString(): string;
+}
+export declare class TSReturnStatement extends ReturnStatement {
+    expression: LanguageExpression;
+    constructor(expression: LanguageExpression);
+}
+export declare class TsTupleAllocStatement implements LanguageStatement {
+    private tuple;
+    constructor(tuple: string);
+    write(writer: LanguageWriter): void;
+}
+export declare class TSLanguageWriter extends LanguageWriter {
+    protected typeConvertor: IdlNameConvertor;
+    constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, language?: Language);
+    maybeSemicolon(): string;
+    pushNamespace(namespace: string, ident?: boolean): void;
+    fork(options?: {
+        resolver?: ReferenceResolver;
+    }): LanguageWriter;
+    getNodeName(type: idl.IDLNode): string;
+    writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], isDeclared?: boolean): void;
+    writeFunctionDeclaration(name: string, signature: MethodSignature): void;
+    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    private generateFunctionDeclaration;
+    writeEnum(name: string, members: {
+        name: string;
+        alias?: string | undefined;
+        stringId: string | undefined;
+        numberId: number;
+    }[]): void;
+    writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
+    writeNativeMethodDeclaration(name: string, signature: MethodSignature, isNative?: boolean): void;
+    writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
+    writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
+    writeMethodImplementation(method: Method, op: (writer: this) => void): void;
+    writeProperty(propName: string, propType: idl.IDLType): void;
+    private writeDeclaration;
+    makeNull(): LanguageExpression;
+    makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
+    makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
+    makeThrowError(message: string): LanguageStatement;
+    makeReturn(expr: LanguageExpression): LanguageStatement;
+    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
+    makeStatement(expr: LanguageExpression): LanguageStatement;
+    makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    writePrintLog(message: string): void;
+    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
+    getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
+    makeUndefined(): LanguageExpression;
+    makeRuntimeType(rt: RuntimeType): LanguageExpression;
+    makeTupleAlloc(option: string): LanguageStatement;
+    makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
+    makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
+    makeMapInit(type: idl.IDLType): LanguageExpression;
+    makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
+    makeUnwrapOptional(expression: LanguageExpression): LanguageExpression;
+    getTagType(): idl.IDLType;
+    getRuntimeType(): idl.IDLType;
+    makeTupleAssign(receiver: string, fields: string[]): LanguageStatement;
+    get supportedModifiers(): MethodModifier[];
+    get supportedFieldModifiers(): FieldModifier[];
+    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
+    ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
+    makeEnumCast(enumName: string, unsafe: boolean, convertor: ArgConvertor): string;
+    castToBoolean(value: string): string;
+    makeCallIsObject(value: string): LanguageExpression;
+    escapeKeyword(keyword: string): string;
+    makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression | undefined;
+    makeSerializerConstructorSignature(): NamedMethodSignature | undefined;
+}
+//# sourceMappingURL=TsLanguageWriter.d.ts.map