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

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

@@ -3,7 +3,6 @@ export declare class Language {
     extension: string;
     static TS: Language;
     static ARKTS: Language;
-    static JAVA: Language;
     static CPP: Language;
     static CJ: Language;
     static KOTLIN: Language;

package/build/lib/src/Language.js

@@ -26,7 +26,6 @@ export class Language {
     static fromString(name) {
         switch (name) {
             case "arkts": return Language.ARKTS;
-            case "java": return Language.JAVA;
             case "ts": return Language.TS;
             case "cangjie": return Language.CJ;
             case "cpp": return Language.CPP;
@@ -37,8 +36,7 @@ export class Language {
 }
 Language.TS = new Language("TS", ".ts");
 Language.ARKTS = new Language("ArkTS", ".ts"); // using .ts for ArkTS until we get rit of tsc preprocessing
-Language.JAVA = new Language("Java", ".java");
-Language.CPP = new Language("C++", ".cc");
+Language.CPP = new Language("C++", ".cpp");
 Language.CJ = new Language("CangJie", ".cj");
 Language.KOTLIN = new Language("Kotlin", ".kt");
 //# sourceMappingURL=Language.js.map

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

@@ -1,12 +1,11 @@
 import * as idl from "../idl";
 import { Language } from "../Language";
-import { ExpressionAssigner, LanguageExpression, LanguageStatement, LanguageWriter, Method } from "./LanguageWriter";
+import { BranchStatement, ExpressionAssigner, LanguageExpression, LanguageStatement, LanguageWriter } from "./LanguageWriter";
 import { NativeModuleType, RuntimeType } from "./common";
 import { LibraryInterface } from "../LibraryInterface";
 import { ReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { PeerLibrary } from "../peer-generation/PeerLibrary";
-import { PeerMethodSignature } from "../peer-generation/PeerMethod";
-export declare function getSerializerName(declaration: idl.IDLEntry): string;
+export declare function getSerializerName(_library: LibraryInterface, _language: Language, declaration: idl.IDLEntry): string;
 export interface ArgConvertor {
     param: string;
     idlType: idl.IDLType;
@@ -26,9 +25,6 @@ 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 | PeerMethodSignature): boolean;
-export declare function isDirectMethod(method: Method, library: PeerLibrary): boolean;
 export declare abstract class BaseArgConvertor implements ArgConvertor {
     idlType: idl.IDLType;
     runtimeTypes: RuntimeType[];
@@ -106,8 +102,9 @@ export declare class NumberConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
 }
 export declare class NumericConvertor extends BaseArgConvertor {
+    protected library: LibraryInterface;
     private readonly interopNameConvertor;
-    constructor(param: string, type: idl.IDLPrimitiveType);
+    constructor(library: LibraryInterface, param: string, type: idl.IDLPrimitiveType);
     convertorArg(param: string, writer: LanguageWriter): string;
     convertorSerialize(param: string, value: string, writer: LanguageWriter): LanguageStatement;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
@@ -277,6 +274,13 @@ export declare class OptionConvertor extends BaseArgConvertor {
     isPointerType(): boolean;
     getObjectAccessor(language: Language, value: string, args?: Record<string, string>): string;
 }
+declare class ConvertorItem {
+    convertor: ArgConvertor;
+    index: number;
+    type: idl.IDLType;
+    elemName?: string | undefined;
+    constructor(convertor: ArgConvertor, index: number, type: idl.IDLType, elemName?: string | undefined);
+}
 export declare class UnionConvertor extends BaseArgConvertor {
     private library;
     private type;
@@ -284,7 +288,13 @@ export declare class UnionConvertor extends BaseArgConvertor {
     private unionChecker;
     constructor(library: LibraryInterface, param: string, type: idl.IDLUnionType);
     convertorArg(param: string, writer: LanguageWriter): string;
+    isSequence(type: idl.IDLType): boolean;
+    isIndexedDiscriminator(writer: LanguageWriter): boolean;
     convertorSerialize(param: string, value: string, printer: LanguageWriter): LanguageStatement;
+    makeStoreSelector(param: string, index: number, printer: LanguageWriter): LanguageStatement;
+    makeBranch(param: string, value: string, printer: LanguageWriter, convertorItem: ConvertorItem): BranchStatement;
+    makeArrayBranch(param: string, value: string, printer: LanguageWriter, arrayConvertorItems: ConvertorItem[]): BranchStatement[];
+    convertorSerializeMultiBranch(param: string, value: string, printer: LanguageWriter, convertors: ConvertorItem[]): LanguageStatement;
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
     nativeType(): idl.IDLType;
     interopType(): idl.IDLType;
@@ -356,4 +366,5 @@ export declare class TransformOnSerializeConvertor extends BaseArgConvertor {
     convertorDeserialize(bufferName: string, deserializerName: string, assigneer: ExpressionAssigner, writer: LanguageWriter): LanguageStatement;
 }
 export declare function createOutArgConvertor(library: PeerLibrary, type: idl.IDLType | undefined, otherParams: string[]): ArgConvertor | undefined;
+export {};
 //# sourceMappingURL=ArgConvertors.d.ts.map

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

@@ -14,84 +14,17 @@
  */
 import * as idl from "../idl";
 import { Language } from "../Language";
-import { BlockStatement, PrintHint, StringExpression, MethodModifier, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
+import { BlockStatement, PrintHint, StringExpression, NamedMethodSignature, ProxyStatement, ExpressionStatement } from "./LanguageWriter";
 import { RuntimeType } from "./common";
 import { generatorConfiguration, generatorTypePrefix } from "../config";
 import { capitalize, getExtractor, getTransformer, hashCodeFromString, throwException, warn } from "../util";
 import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 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";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
-import { PeerMethodSignature } from "../peer-generation/PeerMethod";
 import { isInExternalModule } from "../peer-generation/modules";
-export function getSerializerName(declaration) {
-    return `${idl.getQualifiedName(declaration, "namespace.name").split('.').join('_')}_serializer`;
-}
-export function isDirectConvertedType(originalType, library) {
-    const debug = false;
-    if (originalType == undefined)
-        return true; // TODO: is it correct?
-    if (debug)
-        console.log(`IDL type ${idl.DebugUtils.debugPrintType(originalType)}`);
-    if (originalType == idl.IDLInteropReturnBufferType)
-        return false;
-    if (originalType == idl.IDLThisType)
-        return true; /* Because this type for native is pointer, right? */
-    if (originalType == idl.IDLSerializerBuffer)
-        return true;
-    let convertor = library.typeConvertor("x", originalType, false);
-    // Resolve aliases.
-    while (convertor instanceof TypeAliasConvertor) {
-        convertor = convertor.convertor;
-    }
-    if (convertor instanceof ArrayConvertor ||
-        convertor instanceof CustomTypeConvertor ||
-        convertor instanceof UnionConvertor ||
-        convertor instanceof CallbackConvertor ||
-        convertor instanceof MapConvertor ||
-        convertor instanceof TupleConvertor ||
-        convertor instanceof AggregateConvertor ||
-        convertor instanceof OptionConvertor ||
-        convertor instanceof ImportTypeConvertor) {
-        // try { console.log(`convertor is ${convertor.constructor.name} for ${JSON.stringify(originalType)}`) } catch (e) {}
-        return false;
-    }
-    let type = convertor.interopType();
-    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
-        || type == idl.IDLF32Type
-        || type == idl.IDLI64Type || type == idl.IDLU64Type
-        || type == idl.IDLPointerType
-        || type == idl.IDLBooleanType
-        || type == idl.IDLVoidType
-        || 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) {
-    var _a, _b;
-    const isPromise = !!idl.asPromise(method instanceof PeerMethodSignature ? method.returnType : method.signature.returnType);
-    return isPromise ||
-        !!((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS)) ||
-        !!((_b = method.modifiers) === null || _b === void 0 ? void 0 : _b.includes(MethodModifier.FORCE_CONTEXT)) ||
-        generatorConfiguration().forceContext.includes(method.name);
-}
-export function isDirectMethod(method, library) {
-    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`)
-    return result;
+export function getSerializerName(_library, _language, declaration) {
+    return `${idl.getQualifiedName(declaration, "package.namespace.name").split('.').map(capitalize).join('')}SerializerImpl`;
 }
 export class BaseArgConvertor {
     constructor(idlType, runtimeTypes, isScoped, useArray, param) {
@@ -298,10 +231,11 @@ export class NumberConvertor extends BaseArgConvertor {
     }
 }
 export class NumericConvertor extends BaseArgConvertor {
-    constructor(param, type) {
+    constructor(library, param, type) {
         // check numericPrimitiveTypes.include(type)
         super(type, [RuntimeType.NUMBER], false, false, param);
-        this.interopNameConvertor = new CppNameConvertor(createEmptyReferenceResolver());
+        this.library = library;
+        this.interopNameConvertor = new CppNameConvertor(this.library);
     }
     convertorArg(param, writer) {
         return param;
@@ -368,7 +302,7 @@ export class ObjectConvertor extends BaseArgConvertor {
         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.writeStatement(writer.makeAssign(name, idl.createReferenceType(`idlize.stdlib.CallbackResource`), writer.makeString(`{${this.param}.resource.resourceId, holdManagedCallbackResource, releaseManagedCallbackResource}`), true));
         writer.writeExpressionStatement(writer.makeMethodCall(holder, 'holdCallbackResource', [
             writer.makeString('&' + name)
         ]));
@@ -541,8 +475,8 @@ export class TupleConvertor extends AggregateConvertor {
     convertorSerialize(param, value, printer) {
         const stmts = this.memberConvertors.flatMap((it, index) => {
             return [
-                printer.makeAssign(`${value}_${index}`, undefined, printer.makeTupleAccess(value, index), true),
-                it.convertorSerialize(param, `${value}_${index}`, printer)
+                printer.makeAssign(`${value}N${index}`, undefined, printer.makeTupleAccess(value, index), true),
+                it.convertorSerialize(param, `${value}N${index}`, printer)
             ];
         });
         return printer.makeBlock(stmts, false);
@@ -577,12 +511,12 @@ export class InterfaceConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorSerialize(param, value, writer) {
-        const accessor = getSerializerName(this.declaration);
+        const accessor = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return writer.makeStatement(writer.makeStaticMethodCall(accessor, 'write', [writer.makeString(`${param}Serializer`), writer.makeString(writer.escapeKeyword(value))]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessor = getSerializerName(this.declaration);
+        const accessor = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessor, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return assigneer(writer.makeStaticMethodCall(accessor, 'read', [writer.makeString(deserializerName)]));
     }
@@ -882,13 +816,13 @@ export class OptionConvertor extends BaseArgConvertor {
         throw new Error("Must never be used");
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const runtimeBufferName = `${bufferName}_runtimeType`;
+        const runtimeBufferName = `${bufferName}RuntimeType`;
         const statements = [];
         statements.push(writer.makeAssign(runtimeBufferName, undefined, writer.makeCast(writer.makeString(`${deserializerName}.readInt8()`), writer.getRuntimeType()), true));
         const bufferType = this.nativeType();
         statements.push(writer.makeAssign(bufferName, bufferType, writer.language === Language.CPP ? undefined : writer.makeNull(this.type), true, false)); // maybe change to generic None
         const thenStatement = new BlockStatement([
-            this.typeConvertor.convertorDeserialize(`${bufferName}_`, deserializerName, (expr) => {
+            this.typeConvertor.convertorDeserialize(`${bufferName}Opt`, deserializerName, (expr) => {
                 const receiver = writer.language === Language.CPP
                     ? `${bufferName}.value` : bufferName;
                 return writer.makeAssign(receiver, undefined, expr, false);
@@ -912,6 +846,14 @@ export class OptionConvertor extends BaseArgConvertor {
         return language === Language.CPP ? `${value}.value` : value;
     }
 }
+class ConvertorItem {
+    constructor(convertor, index, type, elemName) {
+        this.convertor = convertor;
+        this.index = index;
+        this.type = type;
+        this.elemName = elemName;
+    }
+}
 export class UnionConvertor extends BaseArgConvertor {
     constructor(library, param, type) {
         super(idl.IDLObjectType, [], false, true, param);
@@ -925,20 +867,68 @@ export class UnionConvertor extends BaseArgConvertor {
     convertorArg(param, writer) {
         throw new Error("Do not use for union");
     }
+    isSequence(type) {
+        return idl.isContainerType(type) && idl.IDLContainerUtils.isSequence(type);
+    }
+    isIndexedDiscriminator(writer) {
+        // Indexed discriminator is only used in CPP
+        // All other languages check the first array element type for arrays discrimination
+        if (writer.language == Language.CPP)
+            return true;
+        return false;
+    }
     convertorSerialize(param, value, printer) {
-        const branches = this.memberConvertors.map((it, index) => {
-            const discriminator = this.unionChecker.makeDiscriminator(value, index, printer);
-            const statements = [];
-            statements.push(printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeString(printer.castToInt(index.toString(), 8))])));
-            if (!(it instanceof UndefinedConvertor)) {
-                const varName = `${value}ForIdx${index}`;
-                statements.push(printer.makeAssign(varName, undefined, printer.makeUnionVariantCast(it.getObjectAccessor(printer.language, value), printer.getNodeName(it.idlType), it, index), true));
-                statements.push(it.convertorSerialize(param, varName, printer));
-            }
-            const stmt = new BlockStatement(statements, false);
-            return { expr: discriminator, stmt };
-        });
-        return printer.makeMultiBranchCondition(branches);
+        const convertorItems = this.memberConvertors.map((it, index) => new ConvertorItem(it, index, it.idlType));
+        if (this.isIndexedDiscriminator(printer))
+            return printer.makeMultiBranchCondition(convertorItems.map(it => this.makeBranch(param, value, printer, it)));
+        // Make arrays type descrimination
+        return this.convertorSerializeMultiBranch(param, value, printer, convertorItems);
+    }
+    makeStoreSelector(param, index, printer) {
+        return printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt8", [printer.makeString(printer.castToInt(index.toString(), 8))]));
+    }
+    makeBranch(param, value, printer, convertorItem) {
+        var _a;
+        const convertor = convertorItem.convertor;
+        const index = convertorItem.index;
+        const type = convertorItem.type;
+        const discriminator = this.unionChecker.makeDiscriminator((_a = convertorItem.elemName) !== null && _a !== void 0 ? _a : value, index, printer, this.library, type);
+        const statements = [];
+        statements.push(this.makeStoreSelector(param, index, printer));
+        if (!(convertor instanceof UndefinedConvertor)) {
+            const varName = `${value}ForIdx${index}`;
+            statements.push(printer.makeAssign(varName, undefined, printer.makeUnionVariantCast(convertor.getObjectAccessor(printer.language, value), printer.getNodeName(convertor.idlType), convertor, index), true));
+            statements.push(convertor.convertorSerialize(param, varName, printer));
+        }
+        const stmt = new BlockStatement(statements, false);
+        return { expr: discriminator, stmt };
+    }
+    makeArrayBranch(param, value, printer, arrayConvertorItems) {
+        if (arrayConvertorItems.length == 0)
+            return [];
+        const arrayConvertorItem = arrayConvertorItems[0];
+        const elemName = `${value}Elem`;
+        const elemAccess = printer.makeString(`${value}[0]`);
+        const checkZeroArray = printer.makeCondition(printer.makeString(`${value}.length == 0`), new BlockStatement([
+            this.makeStoreSelector(param, arrayConvertorItem.index, printer),
+            printer.makeStatement(printer.makeMethodCall(`${param}Serializer`, "writeInt32", [printer.makeString("0")]))
+        ], true, false), new BlockStatement([
+            printer.makeAssign(elemName, undefined, elemAccess, true, true),
+            this.convertorSerializeMultiBranch(param, value, printer, arrayConvertorItems.map(it => new ConvertorItem(it.convertor, it.index, it.type.elementType[0], elemName)))
+        ], true, false));
+        const arrayMultiBranch = {
+            expr: this.unionChecker.makeDiscriminator(value, arrayConvertorItems[0].index, printer, this.library, arrayConvertorItem.type),
+            stmt: checkZeroArray
+        };
+        return [arrayMultiBranch];
+    }
+    convertorSerializeMultiBranch(param, value, printer, convertors) {
+        return printer.makeMultiBranchCondition([
+            ...convertors
+                .filter(it => !this.isSequence(it.type))
+                .map(it => this.makeBranch(param, value, printer, it)),
+            ...this.makeArrayBranch(param, value, printer, convertors.filter(it => this.isSequence(it.type)))
+        ]);
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
         const statements = [];
@@ -983,7 +973,7 @@ export class UnionConvertor extends BaseArgConvertor {
         return language === Language.CPP && (args === null || args === void 0 ? void 0 : args.index) ? `${value}.value${args.index}` : value;
     }
     unionDiscriminator(value, index, writer, duplicates) {
-        return writer.makeNaryOp("||", this.memberConvertors.map((_, n) => this.unionChecker.makeDiscriminator(value, n, writer)));
+        return writer.makeNaryOp("||", this.memberConvertors.map((_, n) => this.unionChecker.makeDiscriminator(value, n, writer, this.library)));
     }
 }
 export class FunctionConvertor extends BaseArgConvertor {
@@ -1018,10 +1008,10 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         this.declaration = declaration;
     }
     convertorArg(param, writer) {
+        const nameConvertor = this.library.createTypeNameConvertor(Language.CPP);
         switch (writer.language) {
             case Language.CPP:
-                return `static_cast<${generatorTypePrefix()}${qualifiedName(this.declaration, "_", "namespace.name")}>(${param})`;
-            case Language.JAVA:
+                return `static_cast<${nameConvertor.convert(this.declaration)}>(${param})`;
             case Language.CJ:
                 return `MaterializedBase.toPeerPtr(${writer.escapeKeyword(param)})`;
             default:
@@ -1033,12 +1023,12 @@ export class MaterializedClassConvertor extends BaseArgConvertor {
         }
     }
     convertorSerialize(param, value, printer) {
-        const accessorRoot = getSerializerName(this.declaration);
+        const accessorRoot = getSerializerName(this.library, printer.language, this.declaration);
         printer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         return printer.makeStatement(printer.makeStaticMethodCall(accessorRoot, 'write', [printer.makeString(`${param}Serializer`), printer.makeString(value)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer) {
-        const accessorRoot = getSerializerName(this.declaration);
+        const accessorRoot = getSerializerName(this.library, writer.language, this.declaration);
         writer.addFeature(accessorRoot, this.library.layout.resolve({ node: this.declaration, role: LayoutNodeRole.SERIALIZER }));
         const readStatement = writer.makeCast(writer.makeStaticMethodCall(accessorRoot, "read", [writer.makeString(deserializerName)]), this.declaration);
         return assigneer(readStatement);
@@ -1115,8 +1105,10 @@ export class CallbackConvertor extends BaseArgConvertor {
                 writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, "writePointer", [writer.makeCast(new StringExpression(`${value}.callSync`), idl.IDLPointerType, { unsafe: true })]))
             ], false);
         }
-        if (this.isTransformed)
-            value = `CallbackTransformer.transformFrom${this.library.getInteropName(this.decl)}(${value})`;
+        if (this.isTransformed) {
+            const convertor = this.library.createTypeNameConvertor(Language.CPP);
+            value = `CallbackTransformer.transformFrom${convertor.convert(this.decl)}(${value})`;
+        }
         return writer.makeStatement(writer.makeMethodCall(`${param}Serializer`, `holdAndWriteCallback`, [writer.makeString(`${value}`)]));
     }
     convertorDeserialize(bufferName, deserializerName, assigneer, writer, useSyncVersion = true) {
@@ -1141,7 +1133,7 @@ export class CallbackConvertor extends BaseArgConvertor {
         const continuationValueName = bufferName + "BufContinuationValue";
         const continuationCallbackName = bufferName + "BufContinuationCallback";
         const statements = [];
-        statements.push(writer.makeAssign(resourceName, idl.createReferenceType("CallbackResource"), writer.makeMethodCall(deserializerName, 'readCallbackResource', []), true));
+        statements.push(writer.makeAssign(resourceName, idl.createReferenceType("idlize.stdlib.CallbackResource"), writer.makeMethodCall(deserializerName, 'readCallbackResource', []), true));
         statements.push(writer.makeAssign(callName, idl.IDLPointerType, writer.makeMethodCall(deserializerName, `readPointer`, []), true));
         statements.push(writer.makeAssign(callSyncName, idl.IDLPointerType, writer.makeMethodCall(deserializerName, 'readPointer', []), true));
         const callbackSignature = new NamedMethodSignature(this.decl.returnType, this.decl.parameters.map(it => idl.maybeOptional(it.type, it.isOptional)), this.decl.parameters.map(it => it.name));
@@ -1167,7 +1159,7 @@ export class CallbackConvertor extends BaseArgConvertor {
             ];
         }
         const result = writer.makeLambda(callbackSignature, [
-            writer.makeAssign(`${argsSerializer}Serializer`, idl.createReferenceType('SerializerBase'), writer.makeMethodCall('SerializerBase', 'hold', []), true),
+            writer.makeAssign(`${argsSerializer}Serializer`, idl.createReferenceType('idlize.internal.SerializerBase'), writer.makeMethodCall('SerializerBase', 'hold', []), true),
             new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `writeInt32`, [writer.makeString(`${resourceName}.resourceId`)])),
             new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `writePointer`, [writer.makeString(callName)])),
             new ExpressionStatement(writer.makeMethodCall(`${argsSerializer}Serializer`, `writePointer`, [writer.makeString(callSyncName)])),
@@ -1221,7 +1213,7 @@ function warnCustomObject(type, msg) {
 }
 export const CallbackKind = "CallbackKind";
 export function generateCallbackKindName(callback) {
-    return `Kind_${callback.name}`;
+    return `KIND_${callback.name.toUpperCase()}`;
 }
 export function generateCallbackKindAccess(callback, language) {
     const name = generateCallbackKindName(callback);
@@ -1250,7 +1242,7 @@ export function generateCallbackAPIArguments(library, callback) {
 }
 export function maybeTransformManagedCallback(callback, library) {
     if (callback.name === "CustomBuilder")
-        return library.resolveTypeReference(idl.createReferenceType("CustomNodeBuilder"));
+        return library.resolveTypeReference(idl.createReferenceType("arkui.component.idlize.CustomNodeBuilder"));
     return undefined;
 }
 class PromiseOutArgConvertor extends BaseArgConvertor {

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

@@ -109,6 +109,12 @@ export declare class MultiBranchIfStatement implements LanguageStatement {
     constructor(statements: BranchStatement[], elseStatement: LanguageStatement | undefined);
     write(writer: LanguageWriter): void;
 }
+export type EnumMember = {
+    name: string;
+    alias?: string;
+    stringId: string | undefined;
+    numberId: number;
+};
 export declare class TsEnumEntityStatement implements LanguageStatement {
     private readonly enumEntity;
     private readonly options;
@@ -146,8 +152,11 @@ export declare enum FieldModifier {
     FINAL = 5,
     VOLATILE = 6,
     INTERNAL = 7,
-    OVERRIDE = 8
+    OVERRIDE = 8,
+    GET = 9,
+    SET = 10
 }
+export declare const ACCESS_MODIFIERS_SET: Set<FieldModifier>;
 export declare enum MethodModifier {
     PUBLIC = 0,
     PRIVATE = 1,
@@ -254,13 +263,9 @@ export declare abstract class LanguageWriter {
     })[];
     addFeature(node: idl.IDLEntry | idl.IDLReferenceType): void;
     addFeature(feature: string, module: string): void;
+    abstract get interopModule(): string;
     abstract writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
-    abstract writeEnum(name: string, members: {
-        name: string;
-        alias?: string;
-        stringId: string | undefined;
-        numberId: number;
-    }[], options: {
+    abstract writeEnum(name: string, members: EnumMember[], options: {
         isExport: boolean;
         isDeclare?: boolean;
     }, op?: (writer: this) => void): void;
@@ -280,6 +285,7 @@ export declare abstract class LanguageWriter {
     }, initExpr?: LanguageExpression): void;
     abstract writeTypeDeclaration(decl: idl.IDLTypedef): void;
     abstract writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
+    abstract writeImports(moduleName: string, importedFeatures: string[], aliases: string[]): void;
     abstract makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression | undefined, isDeclared: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     abstract makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     abstract makeThrowError(message: string): LanguageStatement;

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

@@ -15,6 +15,7 @@
 import * as idl from "../idl";
 import * as fs from "fs";
 import { RuntimeType } from "./common";
+import { withInsideInstanceof } from "./nameConvertor";
 export class TernaryExpression {
     constructor(condition, trueExpression, falseExpression) {
         this.condition = condition;
@@ -307,7 +308,14 @@ export var FieldModifier;
     FieldModifier[FieldModifier["VOLATILE"] = 6] = "VOLATILE";
     FieldModifier[FieldModifier["INTERNAL"] = 7] = "INTERNAL";
     FieldModifier[FieldModifier["OVERRIDE"] = 8] = "OVERRIDE";
+    FieldModifier[FieldModifier["GET"] = 9] = "GET";
+    FieldModifier[FieldModifier["SET"] = 10] = "SET";
 })(FieldModifier || (FieldModifier = {}));
+export const ACCESS_MODIFIERS_SET = new Set([
+    FieldModifier.PRIVATE,
+    FieldModifier.PROTECTED,
+    FieldModifier.PUBLIC
+]);
 export var MethodModifier;
 (function (MethodModifier) {
     MethodModifier[MethodModifier["PUBLIC"] = 0] = "PUBLIC";
@@ -683,11 +691,11 @@ export class LanguageWriter {
         op(this);
     }
     instanceOf(value, type) {
-        return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
+        return this.makeString(`${value} instanceof ${withInsideInstanceof(true, () => this.getNodeName(type))}`);
     }
     // The version of instanceOf() which does not use ArgConvertors
     typeInstanceOf(type, value, members) {
-        return this.makeString(`${value} instanceof ${this.getNodeName(type)}`);
+        return this.makeString(`${value} instanceof ${withInsideInstanceof(true, () => this.getNodeName(type))}`);
     }
     /**
      * Writes `namespace <namespace> {` and adds extra indent

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

@@ -14,4 +14,5 @@ export declare class NativeModuleType {
     name: string;
     constructor(name: string);
 }
+export declare const InteropModuleType: NativeModuleType;
 //# sourceMappingURL=common.d.ts.map

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024 Huawei Device Co., Ltd.
+ * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
@@ -30,4 +30,5 @@ export class NativeModuleType {
         this.name = name;
     }
 }
+export const InteropModuleType = new NativeModuleType("InteropNativeModule");
 //# sourceMappingURL=common.js.map

package/build/lib/src/LanguageWriters/convertors/CJConvertors.d.ts

@@ -32,5 +32,4 @@ export declare class CJIDLTypeToForeignStringConvertor extends CJTypeNameConvert
 export declare class CJInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
-export declare function removePoints(s: string): string;
 //# sourceMappingURL=CJConvertors.d.ts.map

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

@@ -15,6 +15,7 @@
 import * as idl from '../../idl';
 import { CJKeywords } from '../../languageSpecificKeywords';
 import { generateSyntheticIdlNodeName } from '../../peer-generation/idl/common';
+import { removePoints } from '../../util';
 import { convertNode, convertType } from '../nameConvertor';
 import { InteropArgConvertor } from './InteropConvertors';
 export class CJTypeNameConvertor {
@@ -199,7 +200,4 @@ export class CJInteropArgConvertor extends InteropArgConvertor {
         return super.convertPrimitiveType(type);
     }
 }
-export function removePoints(s) {
-    return s.split(/[\.\-]/g).join('_');
-}
 //# sourceMappingURL=CJConvertors.js.map

package/build/lib/src/LanguageWriters/convertors/CppConvertors.d.ts

@@ -1,16 +1,16 @@
 import * as idl from '../../idl';
 import { IdlNameConvertor, NodeConvertor, TypeConvertor } from "../nameConvertor";
 import { InteropArgConvertor } from './InteropConvertors';
-import { ReferenceResolver } from '../../peer-generation/ReferenceResolver';
+import { LibraryInterface } from '../../LibraryInterface';
 export interface ConvertResult {
     text: string;
     noPrefix: boolean;
     resolvedType: idl.IDLType;
 }
 export declare class GenericCppConvertor implements NodeConvertor<ConvertResult> {
-    protected resolver: ReferenceResolver;
-    constructor(resolver: ReferenceResolver);
-    private make;
+    protected library: LibraryInterface;
+    constructor(library: LibraryInterface);
+    protected make(text: string, resolvedType: idl.IDLType, noPrefix?: boolean): ConvertResult;
     convertNode(node: idl.IDLNode): ConvertResult;
     convertNamespace(node: idl.IDLNamespace): ConvertResult;
     convertInterface(node: idl.IDLInterface): ConvertResult;
@@ -29,6 +29,8 @@ export declare class GenericCppConvertor implements NodeConvertor<ConvertResult>
     convertPrimitiveType(type: idl.IDLPrimitiveType): ConvertResult;
     private qualifiedName;
     private computeTargetTypeLiteralName;
+    protected isInsideStructure: boolean;
+    protected insideStructure<T>(cb: () => T): T;
 }
 export declare class CppConvertor extends GenericCppConvertor implements IdlNameConvertor {
     private unwrap;
@@ -36,9 +38,13 @@ export declare class CppConvertor extends GenericCppConvertor implements IdlName
     convert(node: idl.IDLNode): string;
 }
 export declare class CppNameConvertor implements IdlNameConvertor {
-    protected resolver: ReferenceResolver;
+    protected library: LibraryInterface;
     private readonly cppConvertor;
-    constructor(resolver: ReferenceResolver);
+    constructor(library: LibraryInterface);
+    convert(node: idl.IDLNode): string;
+}
+export declare class StructureNameConvertor extends CppConvertor {
+    constructor(library: LibraryInterface);
     convert(node: idl.IDLNode): string;
 }
 export declare class CppInteropArgConvertor extends InteropArgConvertor {
@@ -47,9 +53,9 @@ export declare class CppInteropArgConvertor extends InteropArgConvertor {
     convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
 export declare class CppReturnTypeConvertor implements TypeConvertor<string> {
-    private resolver;
+    private library;
     private convertor;
-    constructor(resolver: ReferenceResolver);
+    constructor(library: LibraryInterface);
     isVoid(returnType: idl.IDLType): boolean;
     convert(type: idl.IDLType): string;
     convertContainer(type: idl.IDLContainerType): string;