@idlizer/core 2.1.10-arktscgen-5 → 2.1.10-arktscgen-6

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

@@ -1,306 +0,0 @@
-/*
- * 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, BlockStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } 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(true)}`;
-    }
-}
-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, body) {
-        this.map = map;
-        this.key = key;
-        this.value = value;
-        this.body = body;
-    }
-    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();`);
-        writer.writeStatement(new BlockStatement(this.body, false));
-        writer.popIndent();
-        writer.print(`}`);
-    }
-}
-////////////////////////////////////////////////////////////////
-//                           WRITER                           //
-////////////////////////////////////////////////////////////////
-export class JavaLanguageWriter extends CLikeLanguageWriter {
-    constructor(printer, resolver, typeConvertor) {
-        super(printer, resolver, Language.JAVA);
-        this.typeConvertor = typeConvertor;
-    }
-    getNodeName(type) {
-        // another stub. Bad one.
-        // I hope that I will rewrite LWs soon
-        if (idl.isType(type) && idl.isReferenceType(type)) {
-            if (type.name.startsWith('%TEXT%:')) {
-                return type.name.substring(7);
-            }
-        }
-        return this.typeConvertor.convert(type);
-    }
-    fork(options) {
-        var _a;
-        return new JavaLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor);
-    }
-    get interopModule() {
-        return "org.koalaui.interop";
-    }
-    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, generics) {
-        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(method) {
-        this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
-    }
-    writeConstructorImplementation(className, signature, op, delegationCall, 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 (delegationCall) {
-            this.print(`super(${delegationCall.delegationArgs.map(it => it.asString()).join(", ")});`);
-        }
-        op(this);
-        this.popIndent();
-        this.printer.print(`}`);
-    }
-    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
-        let isStatic = modifiers.includes(FieldModifier.STATIC);
-        let isMutable = !modifiers.includes(FieldModifier.READONLY);
-        let containerName = propName.concat("_container");
-        if (getter) {
-            if (!getter.op) {
-                this.print(`private var ${this.getNodeName(propType)} ${containerName};`);
-            }
-            this.writeGetterImplementation(new Method(propName, new MethodSignature(propType, []), isStatic ? [MethodModifier.STATIC, MethodModifier.PUBLIC] : [MethodModifier.PUBLIC]), getter ? getter.op :
-                (writer) => {
-                    writer.print(`return ${containerName}`);
-                });
-            if (isMutable) {
-                const setSignature = new NamedMethodSignature(idl.IDLVoidType, [propType], [propName]);
-                this.writeSetterImplementation(new Method(propName, setSignature, isStatic ? [MethodModifier.STATIC, MethodModifier.PUBLIC] : [MethodModifier.PUBLIC]), setter ? setter.op :
-                    (writer) => {
-                        writer.print(`${containerName} = ${propName};`);
-                    });
-            }
-        }
-        else {
-            // TBD: use initExpr
-            this.writeMethodDeclaration(propName, new MethodSignature(propType, []));
-        }
-    }
-    writeTypeDeclaration(decl) {
-        throw new Error(`Type declarations do not exist in Java, use something else`);
-    }
-    writeConstant(constName, constType, constVal) {
-        throw new Error("writeConstant for Java is not implemented yet.");
-    }
-    writeImports(moduleName, importedFeatures, aliases) {
-        if (importedFeatures.length !== aliases.length) {
-            throw new Error(`Inconsistent imports from ${moduleName}`);
-        }
-        for (let i = 0; i < importedFeatures.length; i++) {
-            this.writeExpressionStatement(this.makeString(`import ${moduleName}.${importedFeatures[i]}`));
-        }
-    }
-    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);
-    }
-    makeDefinedCheck(value) {
-        return this.makeString(`${value} != null`);
-    }
-    makeLoop(counter, limit, statement) {
-        return new CLikeLoopStatement(counter, limit, statement);
-    }
-    makeMapForEach(map, key, value, body) {
-        return new JavaMapForEachStatement(map, key, value, body);
-    }
-    makeMapSize(map) {
-        return this.makeString(`${map}.size()`);
-    }
-    makeCast(value, node, options) {
-        var _a;
-        return new JavaCastExpression(value, this.getNodeName(node), (_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}`);
-    }
-    enumFromI32(value, enumEntry) {
-        const enumName = idl.forceAsNamedNode(enumEntry).name;
-        const ordinal = value.asString();
-        return this.makeString(`${enumName}.values()[${ordinal}]`);
-    }
-    makeValueFromOption(value) {
-        return this.makeString(`${value}`);
-    }
-    runtimeType(param, valueType, value) {
-        this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
-    }
-    i32FromEnum(value, enumEntry) {
-        const i32Value = idl.isStringEnum(enumEntry)
-            ? `${value.asString()}.ordinal`
-            : `${value.asString()}.value`;
-        return this.makeString(i32Value);
-    }
-    castToBoolean(value) { return value; }
-}
-//# sourceMappingURL=JavaLanguageWriter.js.map

package/build/lib/src/from-idl/webidl2-utils.d.ts

@@ -1,21 +0,0 @@
-import * as webidl2 from "webidl2";
-export declare function isEnum(node: webidl2.IDLRootType): node is webidl2.EnumType;
-export declare function isInterface(node: webidl2.IDLRootType): node is webidl2.InterfaceType;
-export declare function isImport(node: webidl2.IDLRootType): node is webidl2.ImportType;
-export declare function isPackage(node: webidl2.IDLRootType): node is webidl2.PackageType;
-export declare function isClass(node: webidl2.IDLRootType): node is webidl2.InterfaceType;
-export declare function isCallback(node: webidl2.IDLRootType): node is webidl2.CallbackType;
-export declare function isTypedef(node: webidl2.IDLRootType): node is webidl2.TypedefType;
-export declare function isDictionary(node: webidl2.IDLRootType): node is webidl2.DictionaryType;
-export declare function isAttribute(node: webidl2.IDLInterfaceMemberType | webidl2.IDLNamespaceMemberType): node is webidl2.AttributeMemberType;
-export declare function isOperation(node: webidl2.IDLInterfaceMemberType | webidl2.IDLNamespaceMemberType): node is webidl2.OperationMemberType;
-export declare function isConstructor(node: webidl2.IDLInterfaceMemberType): node is webidl2.ConstructorMemberType;
-export declare function isUnionTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.UnionTypeDescription;
-export declare function isSingleTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.SingleTypeDescription;
-export declare function isSequenceTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.SequenceTypeDescription;
-export declare function isPromiseTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.PromiseTypeDescription;
-export declare function isRecordTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.RecordTypeDescription;
-export declare function isConstant(node: webidl2.IDLRootType): node is webidl2.ConstantMemberType;
-export declare function isUnspecifiedGenericTypeDescription(node: webidl2.IDLTypeDescription): node is webidl2.UnspecifiedGenericTypeDescription;
-export declare function isOptional(node: webidl2.AttributeMemberType | webidl2.OperationMemberType): boolean;
-//# sourceMappingURL=webidl2-utils.d.ts.map

package/build/lib/src/from-idl/webidl2-utils.js

@@ -1,87 +0,0 @@
-/*
- * 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 { IDLEntity } from "../idl";
-export function isEnum(node) {
-    return node.type === "enum";
-}
-export function isInterface(node) {
-    return node.type === "interface";
-}
-export function isImport(node) {
-    return node.type === "import";
-}
-export function isPackage(node) {
-    return node.type === "package";
-}
-export function isClass(node) {
-    var _a, _b;
-    return isInterface(node)
-        && ((_b = (_a = node.extAttrs.find(it => it.name === "Entity")) === null || _a === void 0 ? void 0 : _a.rhs) === null || _b === void 0 ? void 0 : _b.value) === IDLEntity.Class;
-}
-export function isCallback(node) {
-    return node.type === "callback";
-}
-export function isTypedef(node) {
-    return node.type === "typedef";
-}
-export function isDictionary(node) {
-    return node.type === "dictionary";
-}
-export function isAttribute(node) {
-    return node.type === "attribute";
-}
-export function isOperation(node) {
-    return node.type === "operation";
-}
-export function isConstructor(node) {
-    return node.type === "constructor";
-}
-export function isUnionTypeDescription(node) {
-    return node.union;
-}
-export function isSingleTypeDescription(node) {
-    return (typeof node.idlType === "string");
-}
-export function isSequenceTypeDescription(node) {
-    return node.generic === "sequence";
-}
-export function isPromiseTypeDescription(node) {
-    return node.generic === "Promise";
-}
-export function isRecordTypeDescription(node) {
-    return node.generic === "record";
-}
-export function isConstant(node) {
-    return node.type === "const";
-}
-export function isUnspecifiedGenericTypeDescription(node) {
-    switch (node.generic) {
-        case "FrozenArray":
-        case "ObservableArray":
-        case "Promise":
-        case "record":
-        case "sequence":
-        case "":
-            return false;
-    }
-    return true;
-}
-export function isOptional(node) {
-    return node.extAttrs
-        .map((it) => it.name)
-        .map((it) => it.toLowerCase())
-        .includes("optional");
-}
-//# sourceMappingURL=webidl2-utils.js.map