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

package/build/lib/src/Language.js

@@ -36,7 +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.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(library: LibraryInterface, language: Language, 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[];
@@ -278,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;
@@ -285,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;
@@ -357,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,7 +14,7 @@
  */
 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";
@@ -22,77 +22,9 @@ import { UnionRuntimeTypeChecker } from "../peer-generation/unions";
 import { CppConvertor, CppNameConvertor } from "./convertors/CppConvertors";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
 import { LayoutNodeRole } from "../peer-generation/LayoutManager";
-import { PeerMethodSignature } from "../peer-generation/PeerMethod";
 import { isInExternalModule } from "../peer-generation/modules";
-import { isTopLevelConflicted } from "../peer-generation/ConflictingDeclarations";
-export function getSerializerName(library, language, declaration) {
-    const qualifier = isTopLevelConflicted(library, language, declaration)
-        ? "package.namespace.name" : "namespace.name";
-    return `${idl.getQualifiedName(declaration, qualifier).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) {
@@ -370,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)
         ]));
@@ -543,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);
@@ -884,7 +816,7 @@ 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();
@@ -914,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);
@@ -927,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 = [];
@@ -985,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 {
@@ -1145,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));
@@ -1171,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)])),
@@ -1254,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;
@@ -117,7 +123,6 @@ export declare class TsEnumEntityStatement implements LanguageStatement {
         isDeclare: boolean;
     });
     write(writer: LanguageWriter): void;
-    private maybeQuoted;
 }
 export declare class ReturnStatement implements LanguageStatement {
     expression?: LanguageExpression | undefined;
@@ -150,6 +155,7 @@ export declare enum FieldModifier {
     GET = 9,
     SET = 10
 }
+export declare const ACCESS_MODIFIERS_SET: Set<FieldModifier>;
 export declare enum MethodModifier {
     PUBLIC = 0,
     PRIVATE = 1,
@@ -258,12 +264,7 @@ export declare abstract class LanguageWriter {
     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;

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

@@ -12,9 +12,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Language } from "../Language";
 import * as idl from "../idl";
 import * as fs from "fs";
 import { RuntimeType } from "./common";
+import { convertDeclaration, withInsideInstanceof } from "./nameConvertor";
+import { createDeclarationNameConvertor } from "../peer-generation/idl/IdlNameConvertor";
 export class TernaryExpression {
     constructor(condition, trueExpression, falseExpression) {
         this.condition = condition;
@@ -234,28 +237,33 @@ export class TsEnumEntityStatement {
         this.options = options;
     }
     write(writer) {
-        // writer.print(this.enumEntity.comment)
-        writer.print(`${this.options.isExport ? "export " : ""}${this.options.isDeclare ? "declare " : ""}enum ${this.enumEntity.name} {`);
-        writer.pushIndent();
+        let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
+        enumName = enumName.split('.').at(-1);
+        const correctStyleNames = [];
+        const originalStyleNames = [];
         this.enumEntity.elements.forEach((member, index) => {
-            // writer.print(member.comment)
-            const initValue = member.initializer
-                ? ` = ${this.maybeQuoted(member.initializer)}` : ``;
-            writer.print(`${member.name}${initValue},`);
-            let originalName = idl.getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
-            if (originalName) {
-                const initValue = ` = ${member.name}`;
-                writer.print(`${originalName}${initValue},`);
-            }
+            var _a;
+            const initText = (_a = member.initializer) !== null && _a !== void 0 ? _a : index;
+            const isTypeString = typeof initText !== "number";
+            const originalName = idl.getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
+            correctStyleNames.push({
+                name: originalName ? member.name : `${member.name}_DUMMY`,
+                alias: undefined,
+                stringId: isTypeString ? initText : undefined,
+                numberId: initText
+            });
+            originalStyleNames.push({
+                name: originalName !== null && originalName !== void 0 ? originalName : member.name,
+                alias: undefined,
+                stringId: isTypeString ? initText : undefined,
+                numberId: initText
+            });
         });
-        writer.popIndent();
-        writer.print(`}`);
-    }
-    maybeQuoted(value) {
-        if (typeof value == "string")
-            return `"${value}"`;
-        else
-            return `${value}`;
+        let members = originalStyleNames;
+        if (this.enumEntity.elements.some(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.OriginalEnumMemberName))) {
+            members = members.concat(correctStyleNames);
+        }
+        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
     }
 }
 export class ReturnStatement {
@@ -310,6 +318,11 @@ export var FieldModifier;
     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";
@@ -685,11 +698,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/CppConvertors.d.ts

@@ -10,7 +10,7 @@ export interface ConvertResult {
 export declare class GenericCppConvertor implements NodeConvertor<ConvertResult> {
     protected library: LibraryInterface;
     constructor(library: LibraryInterface);
-    private make;
+    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;
@@ -41,6 +43,10 @@ export declare class CppNameConvertor implements IdlNameConvertor {
     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 {
     static INSTANCE: CppInteropArgConvertor;
     convertOptional(type: idl.IDLOptionalType): string;

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

@@ -37,6 +37,7 @@ function isSubtypeTopLevelConflicted(library, node) {
 export class GenericCppConvertor {
     constructor(library) {
         this.library = library;
+        this.isInsideStructure = false;
     }
     make(text, resolvedType, noPrefix = false) {
         return { text, noPrefix, resolvedType };
@@ -90,28 +91,29 @@ export class GenericCppConvertor {
         return this.make(prefix + converted.text, type, true);
     }
     convertUnion(type) {
-        if (isSubtypeTopLevelConflicted(this.library, type)) {
+        return this.insideStructure(() => {
             if (type.parent && idl.isTypedef(type.parent)) {
                 return this.make(type.parent.name, type, false);
             }
             return this.make('Union_' + type.types.map(it => convertType(this, it).text).join("_"), type, false);
-        }
-        return this.make(type.name, type, false);
+        });
     }
     convertContainer(type) {
-        if (idl.IDLContainerUtils.isPromise(type)) {
-            return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`, type);
-        }
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            if (type.elementType[0] === idl.IDLU8Type) {
-                return this.make(`uint8_t*`, type, true);
+        return this.insideStructure(() => {
+            if (idl.IDLContainerUtils.isPromise(type)) {
+                return this.make(`Promise_${this.convertNode(type.elementType[0]).text}`, type);
             }
-            return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, type, true);
-        }
-        if (idl.IDLContainerUtils.isRecord(type)) {
-            return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, type, true);
-        }
-        throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+            if (idl.IDLContainerUtils.isSequence(type)) {
+                if (type.elementType[0] === idl.IDLU8Type) {
+                    return this.make(`uint8_t*`, type, true);
+                }
+                return this.make(`Array_${this.convertNode(type.elementType[0]).text}`, type, true);
+            }
+            if (idl.IDLContainerUtils.isRecord(type)) {
+                return this.make(`Map_${this.convertNode(type.elementType[0]).text}_${this.convertNode(type.elementType[1]).text}`, type, true);
+            }
+            throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
+        });
     }
     convertImport(type) {
         console.warn("Imports are not implemented yet");
@@ -142,6 +144,26 @@ export class GenericCppConvertor {
         return this.make('CustomObject', idl.IDLCustomObjectType);
     }
     convertPrimitiveType(type) {
+        if (this.isInsideStructure) {
+            switch (type) {
+                case idl.IDLVoidType:
+                    return this.make(`Void`, type);
+                case idl.IDLI32Type:
+                    return this.make('I32', type);
+                case idl.IDLU32Type:
+                    return this.make('U32', type);
+                case idl.IDLF32Type:
+                    return this.make('F32', type);
+                case idl.IDLI64Type:
+                    return this.make('I64', type);
+                case idl.IDLU64Type:
+                    return this.make('U64', type);
+                case idl.IDLF64Type:
+                    return this.make('F64', type);
+                case idl.IDLPointerType:
+                    return this.make('Pointer', type);
+            }
+        }
         switch (type) {
             case idl.IDLThisType: // maybe fix it in another level?
             case idl.IDLVoidType: return this.make('void', type, true);
@@ -190,6 +212,13 @@ export class GenericCppConvertor {
         const names = Array.from(map.keys()).map(key => `${key}_${map.get(key).join('_')}`);
         return `Literal_${names.join('_')}`;
     }
+    insideStructure(cb) {
+        const prevIsInsideScructure = this.isInsideStructure;
+        this.isInsideStructure = true;
+        const result = cb();
+        this.isInsideStructure = prevIsInsideScructure;
+        return result;
+    }
 }
 export class CppConvertor extends GenericCppConvertor {
     unwrap(type, result) {
@@ -234,6 +263,15 @@ export class CppNameConvertor {
         return this.cppConvertor.convertNode(node).text;
     }
 }
+export class StructureNameConvertor extends CppConvertor {
+    constructor(library) {
+        super(library);
+        this.isInsideStructure = true;
+    }
+    convert(node) {
+        return this.convertNode(node).text;
+    }
+}
 export class CppInteropArgConvertor extends InteropArgConvertor {
     convertOptional(type) {
         return PrimitiveTypesInstance.NativePointer.getText();

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

@@ -10,5 +10,6 @@ export declare class ETSTypeNameConvertor extends TSTypeNameConvertor {
     protected mapFunctionType(typeArgs: string[]): string;
 }
 export declare class ETSInteropArgConvertor extends TSInteropArgConvertor {
+    convertPrimitiveType(type: idl.IDLPrimitiveType): string;
 }
 //# sourceMappingURL=ETSConvertors.d.ts.map