@idlizer/core 2.1.0 → 2.1.5

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

@@ -80,7 +80,10 @@ export declare class CJLanguageWriter extends LanguageWriter {
         name: string;
         stringId: string | undefined;
         numberId: number;
-    }[], op: (writer: LanguageWriter) => void): void;
+    }[], options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }, op: (writer: LanguageWriter) => void): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
     writeFunctionDeclaration(name: string, signature: MethodSignature): void;
     writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
@@ -89,15 +92,23 @@ 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;
     writeNativeMethodDeclaration(method: Method): void;
-    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
+    i32FromEnum(value: LanguageExpression, _enumEntry: idl.IDLEnum): LanguageExpression;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeClassInit(type: idl.IDLType, parameters: LanguageExpression[]): LanguageExpression;
     makeArrayInit(type: idl.IDLContainerType, size?: number): LanguageExpression;
@@ -117,14 +128,14 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeDefinedCheck(value: string): LanguageExpression;
     makeNewObject(objectName: string, params?: LanguageExpression[]): LanguageExpression;
     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: BaseArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
     makeUnwrapOptional(expression: LambdaExpression): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeRuntimeType(rt: RuntimeType): LanguageExpression;
-    makeRuntimeTypeGetterCall(value: string): LanguageExpression;
+    protected makeRuntimeTypeGetterCall(value: string): LanguageExpression;
     makeMapInsert(keyAccessor: string, key: string, valueAccessor: string, value: string): LanguageStatement;
     makeNull(value?: string): LanguageExpression;
     getTagType(): idl.IDLType;
@@ -136,9 +147,11 @@ export declare class CJLanguageWriter extends LanguageWriter {
     makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, convertorIndex?: number): LanguageExpression;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
-    makeEnumEntity(enumEntity: idl.IDLEnum, isExport: boolean): LanguageStatement;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    makeEnumEntity(enumEntity: idl.IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     escapeKeyword(word: string): string;
@@ -146,7 +159,5 @@ export declare class CJLanguageWriter extends LanguageWriter {
     popNamespace(ident?: boolean): void;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
-    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
 }
 //# sourceMappingURL=CJLanguageWriter.d.ts.map

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

@@ -283,7 +283,7 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeEnum(name, members, op) {
+    writeEnum(name, members, options, op) {
         this.printer.print(`public enum ${name}{`);
         this.pushIndent();
         for (const member of members) {
@@ -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(", ")}) }`);
@@ -410,8 +428,8 @@ export class CJLanguageWriter extends LanguageWriter {
         name = name.startsWith('_') ? name.slice(1) : name;
         this.print(`func ${name}(${signture}): ${this.typeForeignConvertor.convert(method.signature.returnType)}`);
     }
-    makeEnumCast(_enumEntry, enumName) {
-        return `${enumName}.value`;
+    i32FromEnum(value, _enumEntry) {
+        return this.makeString(`${value.asString()}.value`);
     }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
         return new CJAssignStatement(variableName, type, expr, isDeclared, isConst);
@@ -423,7 +441,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString(`ArrayList<${this.getNodeName(type.elementType[0])}>(Int64(${size !== null && size !== void 0 ? size : ''}))`);
     }
     makeMapInit(type) {
-        throw new Error(`TBD`);
+        return this.makeString(`${this.getNodeName(type)}()`);
     }
     makeArrayLength(array, length) {
         return this.makeString(`${array}.size`);
@@ -477,9 +495,9 @@ export class CJLanguageWriter extends LanguageWriter {
     writePrintLog(message) {
         this.print(`println("${message}")`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new CJCastExpression(value, this.getNodeName(type), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new CJCastExpression(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)) {
@@ -507,7 +525,7 @@ export class CJLanguageWriter extends LanguageWriter {
         return this.makeString(methodCall.asString() + '.ordinal');
     }
     makeMapInsert(keyAccessor, key, valueAccessor, value) {
-        return this.makeStatement(this.makeMethodCall(keyAccessor, "set", [this.makeString(key), this.makeString(value)]));
+        return this.makeStatement(this.makeMethodCall(keyAccessor, "add", [this.makeString(key), this.makeString(value)]));
     }
     makeNull(value) {
         return new StringExpression(`Option.None`);
@@ -539,14 +557,11 @@ export class CJLanguageWriter extends LanguageWriter {
     makeTupleAccess(value, index) {
         return this.makeString(`${value}.value${index}`);
     }
-    enumFromOrdinal(value, enumEntry) {
+    enumFromI32(value, enumEntry) {
         return this.makeString(`${this.getNodeName(enumEntry)}(${value.asString()})`);
     }
-    ordinalFromEnum(value, _) {
-        return this.makeString(`Int32(${value.asString()}.value)`);
-    }
-    makeEnumEntity(enumEntity, isExport) {
-        return new CJEnumWithGetter(enumEntity, isExport);
+    makeEnumEntity(enumEntity, options) {
+        return new CJEnumWithGetter(enumEntity, options.isExport);
     }
     makeEquals(args) {
         return this.makeString(`refEq(${args.map(arg => `${arg.asString()}`).join(`, `)})`);
@@ -565,29 +580,5 @@ export class CJLanguageWriter extends LanguageWriter {
     castToBoolean(value) {
         return `if (${value}) { Int32(1) } else { Int32(0) }`;
     }
-    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}.getValue1()`)]))
-        ], false);
-    }
-    makeLengthDeserializer(deserializer) {
-        const valueType = "valueType";
-        return this.makeBlock([
-            this.makeAssign(valueType, undefined, this.makeMethodCall(deserializer, "readInt8", []), true),
-            this.makeMultiBranchCondition([{
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.NUMBER, ''),
-                    stmt: this.makeReturn(this.makeString(`Ark_Length(${deserializer}.readFloat32())`))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.STRING, ''),
-                    stmt: this.makeReturn(this.makeString(`Ark_Length(${deserializer}.readString())`))
-                },
-                {
-                    expr: this.makeRuntimeTypeCondition(valueType, true, RuntimeType.OBJECT, ''),
-                    stmt: this.makeReturn(this.makeString(`Ark_Length(Resource(${deserializer}.readString(), "", 0.0, Option.None, Option.None))`))
-                }], this.makeReturn(this.makeUndefined())),
-        ], false);
-    }
 }
 //# sourceMappingURL=CJLanguageWriter.js.map

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

@@ -37,7 +37,10 @@ export declare abstract class CLikeLanguageWriter extends LanguageWriter {
         name: string;
         stringId: string | undefined;
         numberId: number;
-    }[], op: (writer: LanguageWriter) => void): void;
+    }[], options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }, op: (writer: LanguageWriter) => void): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
     private writeDeclaration;
     protected stringifyMethodReturnType(type: idl.IDLType, _?: PrintHint): string;

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

@@ -95,7 +95,7 @@ export class CLikeLanguageWriter extends LanguageWriter {
     writeMethodDeclaration(name, signature, modifiers) {
         this.writeDeclaration(name, signature, modifiers, ";");
     }
-    writeEnum(name, members, op) {
+    writeEnum(name, members, options, op) {
         throw new Error("WriteEnum for C-family languages is not implemented");
     }
     writeMethodImplementation(method, op) {

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

@@ -11,9 +11,9 @@ import * as idl from "../../idl";
 export declare class CppCastExpression implements LanguageExpression {
     convertor: IdlNameConvertor;
     value: LanguageExpression;
-    type: IDLType;
+    node: IDLNode;
     private options?;
-    constructor(convertor: IdlNameConvertor, value: LanguageExpression, type: IDLType, options?: MakeCastOptions | undefined);
+    constructor(convertor: IdlNameConvertor, value: LanguageExpression, node: IDLNode, options?: MakeCastOptions | undefined);
     asString(): string;
     private mapTypeWithReceiver;
 }
@@ -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;
     /**
@@ -85,7 +91,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeMapInit(type: IDLType): LanguageExpression;
     makeArrayResize(array: string, arrayType: string, length: string, deserializer: string): LanguageStatement;
     makeMapResize(mapTypeName: string, keyType: IDLType, valueType: IDLType, map: string, size: string, deserializer: string): LanguageStatement;
-    makeCast(expr: LanguageExpression, type: IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(expr: LanguageExpression, node: IDLNode, options?: MakeCastOptions): LanguageExpression;
     makePointerPropertyAccessExpression(expression: string, name: string): CppPointerPropertyAccessExpression;
     writePrintLog(message: string): void;
     makeDefinedCheck(value: string): LanguageExpression;
@@ -101,19 +107,19 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeTupleAssign(receiver: string, tupleFields: string[]): LanguageStatement;
     get supportedModifiers(): MethodModifier[];
     get supportedFieldModifiers(): FieldModifier[];
-    enumFromOrdinal(value: LanguageExpression, type: IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, _: IDLType): LanguageExpression;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     makeUnsafeCast(param: string): string;
     makeUnsafeCast_(value: LanguageExpression, type: IDLType, typeOptions?: PrintHint): string;
-    makeEnumCast(enumEntry: idl.IDLEnum, value: string): string;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     escapeKeyword(name: string): string;
-    makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
+    makeEnumEntity(enumEntity: IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     private decayTypeName;
     stringifyMethodReturnType(type: IDLType, hint?: PrintHint): string;
     stringifyMethodArgType(type: IDLType, hint?: PrintHint): string;
     stringifyTypeWithReceiver(type: IDLType, receiver?: string): string;
     makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
-    makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
-    makeLengthDeserializer(deserializer: string): LanguageStatement | undefined;
 }
 //# sourceMappingURL=CppLanguageWriter.d.ts.map

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";
@@ -25,15 +25,15 @@ import * as idl from "../../idl";
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
 export class CppCastExpression {
-    constructor(convertor, value, type, options) {
+    constructor(convertor, value, node, options) {
         this.convertor = convertor;
         this.value = value;
-        this.type = type;
+        this.node = node;
         this.options = options;
     }
     asString() {
         var _a, _b, _c, _d;
-        if (forceAsNamedNode(this.type).name === "Tag") {
+        if (forceAsNamedNode(this.node).name === "Tag") {
             return `${this.value.asString()} == ${PrimitiveTypeList.UndefinedRuntime} ? ${PrimitiveTypeList.UndefinedTag} : ${PrimitiveTypeList.ObjectTag}`;
         }
         let resultName = '';
@@ -41,7 +41,7 @@ export class CppCastExpression {
             resultName = this.options.overrideTypeName;
         }
         else {
-            const pureName = this.mapTypeWithReceiver(this.type, (_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver);
+            const pureName = this.mapTypeWithReceiver((_b = this.options) === null || _b === void 0 ? void 0 : _b.receiver);
             const qualifiedName = ((_c = this.options) === null || _c === void 0 ? void 0 : _c.toRef) ? `${pureName}&` : pureName;
             resultName = qualifiedName;
         }
@@ -49,12 +49,12 @@ export class CppCastExpression {
             ? `reinterpret_cast<${resultName}>(${this.value.asString()})`
             : `static_cast<${resultName}>(${this.value.asString()})`;
     }
-    mapTypeWithReceiver(type, receiver) {
+    mapTypeWithReceiver(receiver) {
         // make deducing type from receiver
         if (receiver !== undefined) {
             return `std::decay<decltype(${receiver})>::type`;
         }
-        return this.convertor.convert(type);
+        return this.convertor.convert(this.node);
     }
 }
 export class CppPointerPropertyAccessExpression {
@@ -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) {
@@ -314,8 +314,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     makeMapResize(mapTypeName, keyType, valueType, map, size, deserializer) {
         return new CppMapResizeStatement(mapTypeName, keyType, valueType, map, size, deserializer);
     }
-    makeCast(expr, type, options) {
-        return new CppCastExpression(this.typeConvertor, expr, type, options);
+    makeCast(expr, node, options) {
+        return new CppCastExpression(this.typeConvertor, expr, node, options);
     }
     makePointerPropertyAccessExpression(expression, name) {
         return new CppPointerPropertyAccessExpression(expression, name);
@@ -370,11 +370,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     get supportedFieldModifiers() {
         return [];
     }
-    enumFromOrdinal(value, type) {
-        return this.makeString(`static_cast<${this.typeConvertor.convert(type)}>(` + value.asString() + `)`);
-    }
-    ordinalFromEnum(value, _) {
-        return value;
+    enumFromI32(value, enumEntry) {
+        return this.makeString(`static_cast<${this.typeConvertor.convert(enumEntry)}>(` + value.asString() + `)`);
     }
     makeUnsafeCast(param) {
         return param;
@@ -396,13 +393,13 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return `(${typeName}) (${value.asString()})`;
     }
-    makeEnumCast(enumEntry, value) {
-        return `static_cast<${this.typeConvertor.convert(idl.createReferenceType(enumEntry))}>(${value})`;
+    i32FromEnum(value, enumEntry) {
+        return this.makeString(`static_cast<${this.typeConvertor.convert(idl.createReferenceType(enumEntry))}>(${value.asString()})`);
     }
     escapeKeyword(name) {
         return cppKeywords.has(name) ? name + "_" : name;
     }
-    makeEnumEntity(enumEntity, isExport) {
+    makeEnumEntity(enumEntity, options) {
         return new CppEnumEntityStatement(enumEntity);
     }
     decayTypeName(typeName) {
@@ -460,20 +457,14 @@ 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]);
+        ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], undefined, [undefined, undefined, undefined, PrintHint.AsPointer]);
         const ownedDataCtor = new NamedMethodSignature(IDLVoidType, [
             createReferenceType("CallbackResourceHolder")
-        ], ["resourceHolder"], [`nullptr`], [undefined, PrintHint.AsPointer]);
+        ], ["resourceHolder"], [`nullptr`], undefined, [undefined, PrintHint.AsPointer]);
         return [ownedDataCtor, fromBufferCtor];
     }
-    makeLengthSerializer(serializer, value) {
-        return undefined;
-    }
-    makeLengthDeserializer(deserializer) {
-        return undefined;
-    }
 }
 //# sourceMappingURL=CppLanguageWriter.js.map

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

@@ -17,8 +17,11 @@ export declare class EtsAssignStatement implements LanguageStatement {
 }
 export declare class ArkTSEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
-    private readonly isExport;
-    constructor(enumEntity: IDLEnum, isExport: boolean);
+    private readonly options;
+    constructor(enumEntity: IDLEnum, options: {
+        isExport: boolean;
+        isDeclare: boolean;
+    });
     write(writer: LanguageWriter): void;
 }
 export declare class ETSLambdaExpression extends LambdaExpression {
@@ -28,8 +31,8 @@ export declare class ETSLambdaExpression extends LambdaExpression {
     asString(): string;
 }
 export declare function generateTypeCheckerName(typeName: string): string;
-export declare function generateEnumToOrdinalName(typeName: string): string;
-export declare function generateEnumFromOrdinalName(typeName: string): string;
+export declare function generateEnumToNumericName(typeName: string): string;
+export declare function generateEnumFromNumericName(typeName: string): string;
 export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
@@ -44,19 +47,21 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     get supportedModifiers(): MethodModifier[];
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
+    i32FromEnum(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
+    enumFromI32(value: LanguageExpression, enumEntry: idl.IDLEnum): LanguageExpression;
     makeDiscriminatorFromFields(convertor: {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
     makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
-    makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
+    makeEnumEntity(enumEntity: IDLEnum, options: {
+        isExport: boolean;
+        isDeclare?: boolean;
+    }): LanguageStatement;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     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;
@@ -67,7 +72,7 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     instanceOf(convertor: ArgConvertor, value: string, duplicateMembers?: Set<string>): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
-    makeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
+    makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
 }
 export declare function makeEnumTypeCheckerCall(valueAccessor: string, enumName: string, writer: LanguageWriter): LanguageExpression;
 //# sourceMappingURL=ETSLanguageWriter.d.ts.map

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

@@ -63,9 +63,9 @@ class ArkTSMapForEachStatement {
     }
 }
 export class ArkTSEnumEntityStatement {
-    constructor(enumEntity, isExport) {
+    constructor(enumEntity, options) {
         this.enumEntity = enumEntity;
-        this.isExport = isExport;
+        this.options = options;
     }
     write(writer) {
         let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
@@ -99,10 +99,7 @@ export class ArkTSEnumEntityStatement {
             }
             return res;
         });
-        const nss = idl.getNamespacesPathFor(this.enumEntity);
-        nss.forEach(it => writer.pushNamespace(it.name));
-        writer.writeEnum(enumName, members);
-        nss.forEach(() => writer.popNamespace());
+        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
     }
 }
 export class ETSLambdaExpression extends LambdaExpression {
@@ -137,13 +134,13 @@ export function generateTypeCheckerName(typeName) {
         .replaceAll('.', ''); // Todo: hack for namespaces
     return `is${typeName.replaceAll('[]', 'Brackets')}`;
 }
-export function generateEnumToOrdinalName(typeName) {
+export function generateEnumToNumericName(typeName) {
     typeName = typeName.split(".").join("_");
-    return `${typeName}_ToOrdinal`;
+    return `${typeName}_ToNumeric`;
 }
-export function generateEnumFromOrdinalName(typeName) {
+export function generateEnumFromNumericName(typeName) {
     typeName = typeName.split(".").join("_");
-    return `${typeName}_FromOrdinal`;
+    return `${typeName}_FromNumeric`;
 }
 export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
@@ -182,13 +179,13 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`${value} as ${type}`);
     }
-    enumFromOrdinal(value, enumEntry) {
+    i32FromEnum(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumFromOrdinalName(enumName), [this.makeString(value.asString())]);
+        return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumName), [value]);
     }
-    ordinalFromEnum(value, enumEntry) {
+    enumFromI32(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumToOrdinalName(enumName), [this.makeString(value.asString())]);
+        return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumName), [value]);
     }
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         if (convertor instanceof AggregateConvertor
@@ -208,8 +205,11 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeIsTypeCall(value, decl) {
         return makeInterfaceTypeCheckerCall(value, decl.name, decl.properties.map(it => it.name), new Set(), this);
     }
-    makeEnumEntity(enumEntity, isExport) {
-        return new ArkTSEnumEntityStatement(enumEntity, isExport);
+    makeEnumEntity(enumEntity, options) {
+        return new ArkTSEnumEntityStatement(enumEntity, {
+            isExport: options === null || options === void 0 ? void 0 : options.isExport,
+            isDeclare: !!(options === null || options === void 0 ? void 0 : options.isDeclare),
+        });
     }
     getObjectAccessor(convertor, value, args) {
         return super.getObjectAccessor(convertor, value, args);
@@ -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);
@@ -307,9 +304,9 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     makeTypeCast(value, type, options) {
         return this.makeString(`TypeChecker.typeCast<${this.getNodeName(type)}>(value)`);
     }
-    makeCast(value, type, options) {
+    makeCast(value, node, options) {
         var _a;
-        return new TSCastExpression(value, `${this.getNodeName(type)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
+        return new TSCastExpression(value, `${this.getNodeName(node)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
 }
 function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {