@idlizer/core 2.1.0 → 2.1.2

package/build/lib/src/LanguageWriters/ArgConvertors.d.ts

@@ -15,6 +15,7 @@ export interface ArgConvertor {
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, writer: LanguageWriter): void;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    holdResource(resourceName: string, holder: string, writer: LanguageWriter): void;
     interopType(): idl.IDLType;
     nativeType(): idl.IDLType;
     targetType(writer: LanguageWriter): string;
@@ -23,6 +24,7 @@ export interface ArgConvertor {
     getMembers(): string[];
     getObjectAccessor(languge: Language, value: string, args?: Record<string, string>, writer?: LanguageWriter): string;
 }
+export declare function isDirectConvertedType(originalType: idl.IDLType | undefined, library: PeerLibrary): boolean;
 export declare function isVMContextMethod(method: Method): boolean;
 export declare function isDirectMethod(method: Method, library: PeerLibrary): boolean;
 export declare abstract class BaseArgConvertor implements ArgConvertor {
@@ -32,6 +34,7 @@ export declare abstract class BaseArgConvertor implements ArgConvertor {
     useArray: boolean;
     param: string;
     protected constructor(idlType: idl.IDLType, runtimeTypes: RuntimeType[], isScoped: boolean, useArray: boolean, param: string);
+    holdResource(_resourceName: string, _holder: string, _writer: LanguageWriter): void;
     nativeType(): idl.IDLType;
     isPointerType(): boolean;
     interopType(): idl.IDLType;
@@ -119,6 +122,16 @@ export declare class BigIntToU64Convertor extends BaseArgConvertor {
     interopType(): idl.IDLType;
     isPointerType(): boolean;
 }
+export declare class ObjectConvertor extends BaseArgConvertor {
+    constructor(param: string);
+    convertorArg(param: string, writer: LanguageWriter): string;
+    convertorSerialize(param: string, value: string, printer: LanguageWriter): void;
+    convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
+    holdResource(name: string, holder: string, writer: LanguageWriter): void;
+    nativeType(): idl.IDLType;
+    interopType(): idl.IDLType;
+    isPointerType(): boolean;
+}
 export declare class PointerConvertor extends BaseArgConvertor {
     constructor(param: string);
     convertorArg(param: string, writer: LanguageWriter): string;

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

@@ -23,30 +23,35 @@ import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { qualifiedName } from "../peer-generation/idl/common";
-function isDirectConvertedType(originalType, library) {
+export function isDirectConvertedType(originalType, library) {
+    const debug = false;
     if (originalType == undefined)
         return true; // TODO: is it correct?
-    if (originalType == idl.IDLInteropReturnBufferType)
+    if (debug)
+        console.log(`IDL type ${idl.DebugUtils.debugPrintType(originalType)}`);
+    if (originalType == idl.IDLInteropReturnBufferType) {
         return false;
-    if (originalType == idl.IDLThisType)
+    }
+    if (originalType == idl.IDLSerializerBuffer)
         return true;
     let convertor = library.typeConvertor("x", originalType, false);
     // Resolve aliases.
     while (convertor instanceof TypeAliasConvertor) {
         convertor = convertor.convertor;
     }
-    // Temporary!
     if (convertor instanceof ArrayConvertor ||
-        convertor instanceof MapConvertor ||
         convertor instanceof CustomTypeConvertor ||
+        convertor instanceof UnionConvertor ||
         convertor instanceof CallbackConvertor ||
+        convertor instanceof MapConvertor ||
+        convertor instanceof TupleConvertor ||
         convertor instanceof AggregateConvertor ||
-        convertor instanceof UnionConvertor) {
-        // try { console.log(`convertor is ${convertor.constructor.name} for ${JSON.stringify(originalType)}`) } catch (e) {}
+        convertor instanceof OptionConvertor) {
         return false;
     }
     let type = convertor.interopType();
-    // TODO: make 'number' be direct!
+    if (debug)
+        console.log(`converted type ${idl.DebugUtils.debugPrintType(originalType)}`);
     let result = type == idl.IDLI8Type || type == idl.IDLU8Type
         || type == idl.IDLI16Type || type == idl.IDLU16Type
         || type == idl.IDLI32Type || type == idl.IDLU32Type
@@ -55,8 +60,11 @@ function isDirectConvertedType(originalType, library) {
         || type == idl.IDLPointerType
         || type == idl.IDLBooleanType
         || type == idl.IDLVoidType
-        || type == idl.IDLUndefinedType;
-    // try { if (!result) console.log(`type ${JSON.stringify(type)} is not direct`) } catch (e) {}
+        || type == idl.IDLUndefinedType
+        || type == idl.IDLSerializerBuffer
+        || type == idl.IDLNumberType;
+    if (!result && debug)
+        console.log(`type ${idl.DebugUtils.debugPrintType(type)} is not direct`);
     return result;
 }
 export function isVMContextMethod(method) {
@@ -66,11 +74,12 @@ export function isVMContextMethod(method) {
         !!((_b = method.modifiers) === null || _b === void 0 ? void 0 : _b.includes(MethodModifier.FORCE_CONTEXT));
 }
 export function isDirectMethod(method, library) {
-    if (isVMContextMethod(method))
+    if (isVMContextMethod(method)) {
         return false;
+    }
     let result = isDirectConvertedType(method.signature.returnType, library) &&
         method.signature.args.every((arg) => isDirectConvertedType(arg, library));
-    //if (!result) console.log(`method ${method.name} is not direct`)
+    // if (!result) console.log(`method ${method.name} is not direct`)
     return result;
 }
 export class BaseArgConvertor {
@@ -81,6 +90,7 @@ export class BaseArgConvertor {
         this.useArray = useArray;
         this.param = param;
     }
+    holdResource(_resourceName, _holder, _writer) { }
     nativeType() {
         throw new Error("Define");
     }
@@ -311,6 +321,50 @@ export class BigIntToU64Convertor extends BaseArgConvertor {
         return false;
     }
 }
+export class ObjectConvertor extends BaseArgConvertor {
+    constructor(param) {
+        super(idl.IDLAnyType, [
+            RuntimeType.BIGINT,
+            RuntimeType.BOOLEAN,
+            RuntimeType.FUNCTION,
+            RuntimeType.MATERIALIZED,
+            RuntimeType.NUMBER,
+            RuntimeType.OBJECT,
+            RuntimeType.STRING,
+            RuntimeType.SYMBOL,
+            RuntimeType.UNDEFINED
+        ], false, true, param);
+    }
+    convertorArg(param, writer) {
+        return writer.escapeKeyword(param);
+    }
+    convertorSerialize(param, value, printer) {
+        if (printer.language === Language.CPP) {
+            printer.writeMethodCall(`${param}Serializer`, "writeObject", [value]);
+        }
+        else {
+            printer.writeMethodCall(`${param}Serializer`, "holdAndWriteObject", [value]);
+        }
+    }
+    convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
+        return assigneer(writer.makeCast(writer.makeMethodCall(deserializerName, 'readObject', []), this.idlType, { optional: false }));
+    }
+    holdResource(name, holder, writer) {
+        writer.writeStatement(writer.makeAssign(name, idl.createReferenceType(`CallbackResource`), writer.makeString(`{${this.param}.resource.resourceId, holdManagedCallbackResource, releaseManagedCallbackResource}`), true));
+        writer.writeExpressionStatement(writer.makeMethodCall(holder, 'holdCallbackResource', [
+            writer.makeString('&' + name)
+        ]));
+    }
+    nativeType() {
+        return idl.IDLAnyType;
+    }
+    interopType() {
+        return idl.IDLAnyType;
+    }
+    isPointerType() {
+        return true;
+    }
+}
 export class PointerConvertor extends BaseArgConvertor {
     constructor(param) {
         // check numericPrimitiveTypes.include(type)

package/build/lib/src/LanguageWriters/LanguageWriter.d.ts

@@ -236,7 +236,13 @@ export declare abstract class LanguageWriter {
     abstract writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     abstract writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     abstract writeMethodImplementation(method: Method, op: (writer: this) => void): void;
-    abstract writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
+    abstract writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op?: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
@@ -347,6 +353,7 @@ export declare abstract class LanguageWriter {
     discriminatorFromExpressions(value: string, runtimeType: RuntimeType, exprs: LanguageExpression[]): LanguageExpression;
     makeDiscriminatorConvertor(_convertor: ArgConvertor, _value: string, _index: number): LanguageExpression | undefined;
     makeNot(expr: LanguageExpression): LanguageExpression;
+    makeSerializedBufferGetter(serializer: string): LanguageExpression;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;

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

@@ -663,6 +663,9 @@ export class LanguageWriter {
     makeNot(expr) {
         return this.makeString(`!(${expr.asString()})`);
     }
+    makeSerializedBufferGetter(serializer) {
+        return this.makeMethodCall(serializer, `asBuffer`, []);
+    }
     makeEquals(args) {
         return this.makeNaryOp("===", args);
     }

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

@@ -140,15 +140,16 @@ export class GenericCppConvertor {
             case idl.IDLBooleanType: return this.make(`Boolean`);
             case idl.IDLBigintType: return this.make(`UInt64`); // TODO add arbitrary precision numeric type
             case idl.IDLPointerType: return this.make('NativePointer');
+            case idl.IDLCustomObjectType: return this.make('CustomObject');
             case idl.IDLUnknownType:
-            case idl.IDLCustomObjectType:
-            case idl.IDLAnyType: return this.make(`CustomObject`);
+            case idl.IDLAnyType: return this.make(`Object`);
             case idl.IDLUndefinedType: return this.make(`Undefined`);
             case idl.IDLLengthType: return this.make(`Length`);
             case idl.IDLFunctionType: return this.make(`Function`);
             case idl.IDLDate: return this.make(`Date`);
             case idl.IDLBufferType: return this.make('Buffer');
             case idl.IDLPointerType: return this.make('Pointer');
+            case idl.IDLSerializerBuffer: return { text: 'KSerializerBuffer', noPrefix: true };
         }
         throw new Error(`Unmapped primitive type ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -218,7 +219,8 @@ export class CppInteropArgConvertor extends InteropArgConvertor {
             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.IDLSerializerBuffer: return "KSerializerBuffer";
+            case idl.IDLBufferType: return "KInteropBuffer";
             case idl.IDLLengthType: return "KLength";
             case idl.IDLFunctionType: return PrimitiveTypesInstance.Int32.getText();
             case idl.IDLDate: return PrimitiveTypesInstance.Int64.getText();

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

@@ -76,7 +76,6 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
                 return 'number';
             case idl.IDLStringType: return 'string';
             case idl.IDLFunctionType: return 'Object';
-            case idl.IDLBufferType: return 'NativeBuffer';
             case idl.IDLBigintType: return 'long';
         }
         return super.convertPrimitiveType(type);

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

@@ -88,6 +88,9 @@ export class InteropReturnTypeConvertor {
                 }
                 return KInteropReturnBuffer;
             }
+            if (idl.isEnum(decl)) {
+                return PrimitiveTypesInstance.Int32.getText();
+            }
         }
         return "void";
     }
@@ -116,6 +119,7 @@ export class InteropArgConvertor {
             case idl.IDLF32Type: return "KFloat";
             case idl.IDLNumberType: return 'KInteropNumber';
             case idl.IDLBigintType: return 'KLong';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLBooleanType:
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';

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

@@ -122,6 +122,7 @@ export class TSTypeNameConvertor {
             case idl.IDLAnyType: return 'any';
             case idl.IDLUndefinedType: return 'undefined';
             case idl.IDLPointerType: return 'KPointer';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
             case idl.IDLVoidType: return 'void';
             case idl.IDLBooleanType: return 'boolean';
             case idl.IDLI32Type:
@@ -145,7 +146,7 @@ export class TSTypeNameConvertor {
             case idl.IDLDate:
                 return 'Date';
             case idl.IDLBufferType:
-                return `ArrayBuffer`;
+                return 'NativeBuffer';
             case idl.IDLInteropReturnBufferType:
                 return `KInteropReturnBuffer`;
         }

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

@@ -89,10 +89,18 @@ export declare class CJLanguageWriter extends LanguageWriter {
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
-    writeProperty(propName: string, propType: idl.IDLType, mutable?: boolean, getterLambda?: (writer: this) => void, setterLambda?: (writer: this) => void): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
+    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op?: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
+    writeGetterImplementation(method: Method, op?: (writer: this) => void): void;
+    writeSetterImplementation(method: Method, op: (writer: this) => void): void;
     writeCJForeign(op: (writer: CJLanguageWriter) => void): void;
     private writeDeclaration;
     writeNativeFunctionCall(printer: LanguageWriter, name: string, signature: MethodSignature): void;

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

@@ -348,33 +348,6 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, mutable, getterLambda, setterLambda) {
-        let shortName = propName.concat("_container");
-        if (!getterLambda) {
-            this.print(`private var ${shortName}: ${this.getNodeName(propType)}`);
-        }
-        this.print(`${mutable ? "mut " : ""}prop ${propName}: ${this.getNodeName(propType)} {`);
-        this.pushIndent();
-        this.print(`get() {`);
-        this.pushIndent();
-        if (getterLambda) {
-            getterLambda(this);
-        }
-        else {
-            this.print(`return ${shortName}`);
-        }
-        this.popIndent();
-        this.print(`}`);
-        if (mutable) {
-            this.print(`set(x) { ${shortName} = x }`);
-            this.pushIndent();
-            if (setterLambda)
-                setterLambda(this);
-            this.popIndent();
-        }
-        this.popIndent();
-        this.print(`}`);
-    }
     writeTypeDeclaration(decl) {
         throw new Error(`writeTypeDeclaration not implemented`);
     }
@@ -389,6 +362,51 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
+    writeProperty(propName, propType, modifiers, getter, setter) {
+        let containerName = propName.concat("_container");
+        let truePropName = this.escapeKeyword(propName);
+        if (getter) {
+            if (!getter.op) {
+                this.print(`private var ${containerName}: ${this.getNodeName(propType)}`);
+            }
+        }
+        let isStatic = modifiers.includes(FieldModifier.STATIC);
+        let isMutable = !modifiers.includes(FieldModifier.READONLY);
+        this.print(`public ${isMutable ? "mut " : ""}${isStatic ? "static " : "open "}prop ${truePropName}: ${this.getNodeName(propType)}`);
+        if (getter) {
+            this.print('{');
+            this.pushIndent();
+            this.writeGetterImplementation(getter.method, getter.op);
+            if (isMutable) {
+                if (setter) {
+                    this.writeSetterImplementation(setter.method, setter ? setter.op : (writer) => { this.print(`${containerName} = ${truePropName}`); });
+                }
+                else {
+                    this.print(`set(${truePropName}) {`);
+                    this.pushIndent();
+                    this.print(`${containerName} = ${truePropName}`);
+                    this.popIndent();
+                    this.print(`}`);
+                }
+            }
+            this.popIndent();
+            this.print('}');
+        }
+    }
+    writeGetterImplementation(method, op) {
+        this.print(`get() {`);
+        this.pushIndent();
+        op ? op(this) : this.print(`return ${method.signature.argsNames.map(arg => `${arg}_container`).join(', ')}`);
+        this.popIndent();
+        this.print('}');
+    }
+    writeSetterImplementation(method, op) {
+        this.print(`set(${method.signature.argsNames.join(', ')}) {`);
+        this.pushIndent();
+        op(this);
+        this.popIndent();
+        this.print('}');
+    }
     writeCJForeign(op) {
         this.print(`foreign {`);
         this.pushIndent();
@@ -399,7 +417,7 @@ export class CJLanguageWriter extends LanguageWriter {
     writeDeclaration(name, signature, modifiers, postfix) {
         let prefix = modifiers === null || modifiers === void 0 ? void 0 : modifiers.filter(it => this.supportedModifiers.includes(it)).map(it => this.mapMethodModifier(it)).join(" ");
         prefix = prefix ? prefix + " " : "";
-        this.print(`${prefix}func ${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
+        this.print(`${prefix}${((modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.SETTER)) || (modifiers === null || modifiers === void 0 ? void 0 : modifiers.includes(MethodModifier.GETTER))) ? '' : 'func '}${name}(${signature.args.map((it, index) => `${this.escapeKeyword(signature.argName(index))}: ${this.getNodeName(it)}`).join(", ")}): ${this.getNodeName(signature.returnType)}${postfix !== null && postfix !== void 0 ? postfix : ""}`);
     }
     writeNativeFunctionCall(printer, name, signature) {
         printer.print(`return unsafe { ${name}(${signature.args.map((it, index) => `${signature.argName(index)}`).join(", ")}) }`);

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

@@ -46,7 +46,13 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeFieldDeclaration(name: string, type: IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
-    writeProperty(propName: string, propType: IDLType, mutable?: boolean): void;
+    writeProperty(propName: string, propType: IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     writeTypeDeclaration(decl: IDLTypedef): void;
     writeConstant(constName: string, constType: IDLType, constVal?: string): void;
     /**

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

@@ -12,7 +12,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createReferenceType, forceAsNamedNode, IDLU32Type, IDLUint8ArrayType, IDLVoidType } from '../../idl';
+import { createReferenceType, forceAsNamedNode, IDLU32Type, IDLVoidType } from '../../idl';
 import { Language } from '../../Language';
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
 import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, NamedMethodSignature, StringExpression } from "../LanguageWriter";
@@ -217,7 +217,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.print(`}`);
     }
-    writeProperty(propName, propType, mutable = true) {
+    writeProperty(propName, propType, modifiers, getter, setter) {
         throw new Error("writeProperty for c++ is not implemented yet.");
     }
     writeTypeDeclaration(decl) {
@@ -460,7 +460,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     }
     makeSerializerConstructorSignatures() {
         const fromBufferCtor = new NamedMethodSignature(IDLVoidType, [
-            IDLUint8ArrayType,
+            idl.IDLSerializerBuffer,
             IDLU32Type,
             createReferenceType("CallbackResourceHolder")
         ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], [undefined, undefined, undefined, PrintHint.AsPointer]);

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

@@ -56,7 +56,6 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     isQuickType(type: IDLType): boolean;
     writeNativeMethodDeclaration(method: Method): void;
-    writeProperty(propName: string, propType: IDLType): void;
     makeUnionVariantCondition(convertor: ArgConvertor, valueName: string, valueType: string, type: string, convertorIndex: number, runtimeTypeIndex: number): LanguageExpression;
     makeCastCustomObject(customName: string, isGenericType: boolean): LanguageExpression;
     makeHasOwnProperty(value: string, valueTypeName: string, property: string, propertyTypeName: string): LanguageExpression;

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

@@ -227,9 +227,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
     }
-    writeProperty(propName, propType) {
-        throw new Error("writeProperty for ArkTS is not implemented yet.");
-    }
     makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
         if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
             return this.instanceOf(convertor, valueName);

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;
@@ -74,7 +80,7 @@ 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;
+    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
     ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
     makeValueFromOption(value: string): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;

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";
@@ -149,8 +149,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`);
@@ -255,11 +276,13 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeTupleAccess(value, index) {
         return this.makeString(`${value}.value${index}`);
     }
-    enumFromOrdinal(value, _) {
-        throw new Error("Method not implemented.");
+    enumFromOrdinal(value, enumEntry) {
+        const enumName = idl.forceAsNamedNode(enumEntry).name;
+        const ordinal = value.asString();
+        return this.makeString(`${enumName}.values()[${ordinal}]`);
     }
     ordinalFromEnum(value, _) {
-        return this.makeString(`${value.asString()}.value`);
+        return this.makeString(`${value.asString()}.ordinal()`);
     }
     makeValueFromOption(value) {
         return this.makeString(`${value}`);

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

@@ -53,7 +53,13 @@ export declare class TSLanguageWriter extends LanguageWriter {
     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;

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

@@ -16,10 +16,11 @@ 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';
+import { isStringEnumType } from '../../peer-generation/isEnumType';
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -223,7 +224,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 +240,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;
@@ -378,7 +400,11 @@ export class TSLanguageWriter extends LanguageWriter {
         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()}]`);
+        const enumName = idl.forceAsNamedNode(enumEntry).name;
+        const ordinal = value.asString();
+        return isStringEnumType(enumEntry, this.resolver)
+            ? this.makeString(`Object.values(${enumName})[${ordinal}]`)
+            : this.makeString(`${ordinal}`);
     }
     ordinalFromEnum(value, enumEntry) {
         const enumName = idl.forceAsNamedNode(enumEntry).name;

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

@@ -9,7 +9,6 @@ export interface LibraryFileInterface {
 export interface LibraryInterface extends ReferenceResolver {
     language: Language;
     get files(): LibraryFileInterface[];
-    get libraryPackages(): string[] | undefined;
     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;