@idlizer/core 2.1.0 → 2.1.5

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

@@ -40,7 +40,13 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeNativeMethodDeclaration(method: Method): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
-    writeProperty(propName: string, propType: idl.IDLType): void;
+    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
@@ -51,7 +57,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     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;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, 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;
@@ -63,7 +69,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
     getTagType(): idl.IDLType;
     getRuntimeType(): idl.IDLType;
@@ -74,12 +80,10 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     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;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     makeValueFromOption(value: string): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     castToBoolean(value: string): string;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
 }
 //# sourceMappingURL=JavaLanguageWriter.d.ts.map

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

@@ -14,7 +14,7 @@
  */
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, CheckOptionalStatement, FieldModifier, LambdaExpression, MethodModifier, } from "../LanguageWriter";
+import { AssignStatement, CheckOptionalStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
 import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import * as idl from '../../idl';
 import { RuntimeType } from "../common";
@@ -100,6 +100,13 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         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) {
@@ -149,8 +156,29 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType) {
-        throw new Error("writeProperty for Java is not implemented yet.");
+    writeProperty(propName, propType, modifiers, getter, setter) {
+        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 {
+            this.writeMethodDeclaration(propName, new MethodSignature(propType, []));
+        }
     }
     writeTypeDeclaration(decl) {
         throw new Error(`Type declarations do not exist in Java, use something else`);
@@ -182,9 +210,9 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeMapSize(map) {
         return this.makeString(`${map}.size()`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, 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);
+        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);
@@ -255,11 +283,10 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     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`);
+    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}`);
@@ -267,15 +294,12 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     runtimeType(param, valueType, value) {
         this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
     }
-    makeEnumCast(_enumEntry, enumName) {
-        return `${enumName}.value`;
+    i32FromEnum(value, enumEntry) {
+        const i32Value = idl.isStringEnum(enumEntry)
+            ? `${value.asString()}.ordinal`
+            : `${value.asString()}.value`;
+        return this.makeString(i32Value);
     }
     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

@@ -47,13 +47,22 @@ export declare class TSLanguageWriter extends LanguageWriter {
         alias?: string | undefined;
         stringId: string | undefined;
         numberId: number;
-    }[]): void;
+    }[], options: {
+        isDeclare?: boolean;
+        isExport: boolean;
+    }): void;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeNativeMethodDeclaration(method: Method): 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;
+    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     private writeDeclaration;
@@ -67,7 +76,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     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;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
@@ -83,9 +92,8 @@ export declare class TSLanguageWriter extends LanguageWriter {
     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(enumEntry: idl.IDLEnum, param: string): string;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;

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

@@ -16,7 +16,7 @@ import * as idl from '../../idl';
 import { isOptionalType } from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, BlockStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { rightmostIndexOf, throwException } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
@@ -135,14 +135,14 @@ export class TSLanguageWriter extends LanguageWriter {
         return new TSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.language);
     }
     getNodeName(type) {
-        // just stub.
-        // language writers and name convertors are subject to rework for namespaces
-        const row = this.typeConvertor.convert(type);
-        const nsPrefix = this.namespaceStack.join('.') + '.';
-        if (row.startsWith(nsPrefix)) {
-            return row.substring(nsPrefix.length);
+        // 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 row;
+        return this.typeConvertor.convert(type);
     }
     writeClass(name, op, superClass, interfaces, generics, isDeclared, isAbstract) {
         let extendsClause = superClass ? ` extends ${superClass}` : '';
@@ -184,8 +184,8 @@ export class TSLanguageWriter extends LanguageWriter {
         const returnType = this.getNodeName(signature.returnType);
         return `export function ${name}(${args.join(", ")}): ${returnType}`;
     }
-    writeEnum(name, members) {
-        this.printer.print(`export enum ${name} {`);
+    writeEnum(name, members, options) {
+        this.printer.print(`${options.isExport ? "export " : ""}${options.isDeclare ? "declare " : ""}enum ${name} {`);
         this.printer.pushIndent();
         for (const [index, member] of members.entries()) {
             let value;
@@ -223,7 +223,7 @@ export class TSLanguageWriter extends LanguageWriter {
         this.writeDeclaration(name, signature, true, false, modifiers);
     }
     writeConstructorImplementation(className, signature, op, superCall, modifiers) {
-        this.writeDeclaration(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') : ''} constructor`, signature, false, true);
+        this.writeDeclaration(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}constructor`, signature, false, true);
         this.pushIndent();
         if (superCall) {
             this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
@@ -239,8 +239,29 @@ export class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType) {
-        throw new Error("writeProperty for TS is not implemented yet.");
+    writeProperty(propName, propType, modifiers, getter, setter) {
+        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] : []), 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] : []), setter ? setter.op :
+                    (writer) => {
+                        writer.print(`${containerName} = ${propName}`);
+                    });
+            }
+        }
+        else {
+            this.writeFieldDeclaration(propName, propType, modifiers, idl.isOptionalType(propType));
+        }
     }
     writeTypeDeclaration(decl) {
         var _a;
@@ -252,7 +273,6 @@ export class TSLanguageWriter extends LanguageWriter {
         this.print(`export const ${constName}: ${this.getNodeName(constType)}${constVal ? ' = ' + constVal : ''}`);
     }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
-        var _a;
         let prefix = !modifiers ? undefined : this.supportedModifiers
             .filter(it => modifiers.includes(it))
             .map(it => this.mapMethodModifier(it)).join(" ");
@@ -268,19 +288,8 @@ export class TSLanguageWriter extends LanguageWriter {
         }
         prefix = prefix ? prefix.trim() + " " : "";
         const typeParams = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : "";
-        // FIXME:
-        const isSetter = modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER);
-        const canBeOptional = [];
-        for (let i = signature.args.length - 1; i >= 0; --i) {
-            const prevCanBeOptional = (_a = canBeOptional.at(-1)) !== null && _a !== void 0 ? _a : true;
-            const curr = signature.args[i];
-            const result = prevCanBeOptional && (idl.isOptionalType(curr) || signature.argDefault(i) !== undefined);
-            canBeOptional.push(result);
-        }
-        canBeOptional.reverse();
-        const isOptional = signature.args.map((it, i) => idl.isOptionalType(it) && canBeOptional[i] && !isSetter);
-        const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && isOptional[i] ? idl.maybeUnwrapOptionalType(it) : it);
-        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${isOptional[index] ? "?" : ""}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
+        const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && signature.isArgOptional(i) ? idl.maybeUnwrapOptionalType(it) : it);
+        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${signature.isArgOptional(index) ? "?" : ``}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
     }
     makeNull() {
         return new StringExpression("undefined");
@@ -312,9 +321,9 @@ export class TSLanguageWriter extends LanguageWriter {
     writePrintLog(message) {
         this.print(`console.log("${message}")`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new TSCastExpression(value, this.getNodeName(/* FIXME: */ idl.maybeUnwrapOptionalType(type)), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new TSCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
     typeInstanceOf(type, value, members) {
         if (idl.isInterface(type)) {
@@ -377,23 +386,19 @@ export class TSLanguageWriter extends LanguageWriter {
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];
     }
-    enumFromOrdinal(value, enumEntry) {
-        return this.makeString(`Object.values(${idl.forceAsNamedNode(enumEntry).name})[${value.asString()}]`);
+    enumFromI32(value, enumEntry) {
+        const enumName = enumEntry.name;
+        const ordinal = value.asString();
+        return idl.isStringEnum(enumEntry)
+            ? this.makeString(`Object.values(${enumName})[${ordinal}]`)
+            : this.makeString(ordinal);
     }
-    ordinalFromEnum(value, enumEntry) {
-        const enumName = idl.forceAsNamedNode(enumEntry).name;
-        const decl = idl.isReferenceType(enumEntry) ? this.resolver.resolveTypeReference(enumEntry) : undefined;
-        if (decl && idl.isEnum(decl) && idl.isStringEnum(decl)) {
+    i32FromEnum(value, enumEntry) {
+        const enumName = this.getNodeName(enumEntry);
+        if (idl.isEnum(enumEntry) && idl.isStringEnum(enumEntry)) {
             return this.makeString(`Object.values(${enumName}).indexOf(${value.asString()})`);
         }
-        return value;
-    }
-    makeEnumCast(enumEntry, param) {
-        // Take the ordinal value if Enum is a string, and valueOf when it is an integer
-        // Enum.valueOf() - compatible with ArkTS/TS
-        return idl.isStringEnum(enumEntry)
-            ? this.ordinalFromEnum(this.makeString(param), idl.createReferenceType(enumEntry)).asString()
-            : `${param}.valueOf()`;
+        return this.makeString(`${value.asString()}.valueOf()`);
     }
     castToBoolean(value) { return `+${value}`; }
     makeCallIsObject(value) {
@@ -411,7 +416,7 @@ export class TSLanguageWriter extends LanguageWriter {
             throwException(`The type reference ${decl === null || decl === void 0 ? void 0 : decl.name} must be Enum`);
         }
         const ordinal = idl.isStringEnum(decl)
-            ? this.ordinalFromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), idl.createReferenceType(this.getNodeName(convertor.nativeType())))
+            ? this.i32FromEnum(this.makeCast(this.makeString(this.getObjectAccessor(convertor, value)), convertor.idlType), decl)
             : this.makeUnionVariantCast(this.getObjectAccessor(convertor, value), this.getNodeName(idl.IDLI32Type), convertor, index);
         const { low, high } = idl.extremumOfOrdinals(decl);
         return this.discriminatorFromExpressions(value, convertor.runtimeTypes[0], [

package/build/lib/src/LibraryInterface.d.ts

@@ -3,13 +3,9 @@ import { Language } from "./Language";
 import { IdlNameConvertor } from "./LanguageWriters";
 import { ArgConvertor } from "./LanguageWriters/ArgConvertors";
 import { ReferenceResolver } from "./peer-generation/ReferenceResolver";
-export interface LibraryFileInterface {
-    get entries(): idl.IDLEntry[];
-}
 export interface LibraryInterface extends ReferenceResolver {
     language: Language;
-    get files(): LibraryFileInterface[];
-    get libraryPackages(): string[] | undefined;
+    get files(): idl.IDLFile[];
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     getInteropName(node: idl.IDLNode): string;