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

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

@@ -14,6 +14,7 @@
  */
 import * as idl from "../../idl";
 import { LanguageWriter } from "../LanguageWriter";
+import { isInsideInstanceof } from "../nameConvertor";
 import { TSInteropArgConvertor, TSTypeNameConvertor } from "./TSConvertors";
 export class ETSTypeNameConvertor extends TSTypeNameConvertor {
     convertTypeReference(type) {
@@ -25,18 +26,13 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         }
         // TODO: Fix for 'TypeError: Type 'Function<R>' is generic but type argument were not provided.'
         if (typeName === "Function") {
-            return "Function<void>";
+            return isInsideInstanceof() ? "Function" : "Function<void>";
         }
         return typeName;
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
-            switch (type.elementType[0]) {
-                case idl.IDLU8Type: return 'KUint8ArrayPtr';
-                case idl.IDLI32Type: return 'KInt32ArrayPtr';
-                case idl.IDLF32Type: return 'KFloat32ArrayPtr';
-            }
-            return `Array<${this.convert(type.elementType[0])}>`;
+            return isInsideInstanceof() ? `Array` : `Array<${this.convert(type.elementType[0])}>`;
         }
         return super.convertContainer(type);
     }
@@ -95,9 +91,15 @@ export class ETSTypeNameConvertor extends TSTypeNameConvertor {
         if (typeArgs.length === 0) {
             typeArgs = [this.convert(idl.IDLVoidType)];
         }
-        return `Function${typeArgs.length - 1}<${typeArgs.join(",")}>`;
+        return isInsideInstanceof() ? `Function${typeArgs.length - 1}` : `Function${typeArgs.length - 1}<${typeArgs.join(",")}>`;
     }
 }
 export class ETSInteropArgConvertor extends TSInteropArgConvertor {
+    convertPrimitiveType(type) {
+        switch (type) {
+            case idl.IDLBigintType: return 'long';
+        }
+        return super.convertPrimitiveType(type);
+    }
 }
 //# sourceMappingURL=ETSConvertors.js.map

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

@@ -84,7 +84,7 @@ export class InteropReturnTypeConvertor {
         if (decl) {
             // Callbacks and array types return by value
             if (idl.isCallback(this.resolver.toDeclaration(type))) {
-                return type.name;
+                return KInteropReturnBuffer;
             }
             if (idl.isInterface(decl)) {
                 if (isMaterialized(decl, this.resolver)) {

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

@@ -17,7 +17,7 @@ import { Language } from '../../Language';
 import { isTopLevelConflicted } from '../../peer-generation/ConflictingDeclarations';
 import { isDeclaredInCurrentFile, LayoutNodeRole } from '../../peer-generation/LayoutManager';
 import { maybeRestoreGenerics } from '../../transformers/GenericTransformer';
-import { convertNode, convertType } from '../nameConvertor';
+import { convertNode, convertType, isInsideInstanceof, withInsideInstanceof } from '../nameConvertor';
 export class TSTypeNameConvertor {
     constructor(library) {
         this.library = library;
@@ -50,6 +50,8 @@ export class TSTypeNameConvertor {
     }
     convertTypedef(node) {
         var _a;
+        if (idl.isSyntheticEntry(node))
+            return this.convert(node.type);
         return (_a = this.mangleTopLevel(node)) !== null && _a !== void 0 ? _a : idl.getQualifiedName(node, "namespace.name");
     }
     convertCallback(node) {
@@ -87,18 +89,13 @@ export class TSTypeNameConvertor {
     }
     convertContainer(type) {
         if (idl.IDLContainerUtils.isSequence(type)) {
-            switch (type.elementType[0]) {
-                case idl.IDLU8Type: return 'Uint8Array'; // should be changed to Array
-                case idl.IDLI32Type: return 'Int32Array'; // should be changed to Array
-                case idl.IDLF32Type: return 'KFloat32ArrayPtr'; // should be changed to Array
-                default: return `Array<${this.convert(type.elementType[0])}>`;
-            }
+            return isInsideInstanceof() ? `Array` : `Array<${this.convert(type.elementType[0])}>`;
         }
         if (idl.IDLContainerUtils.isRecord(type)) {
-            return `Map<${this.convert(type.elementType[0])}, ${this.convert(type.elementType[1])}>`;
+            return isInsideInstanceof() ? `Map` : `Map<${this.convert(type.elementType[0])}, ${this.convert(type.elementType[1])}>`;
         }
         if (idl.IDLContainerUtils.isPromise(type)) {
-            return `Promise<${this.convert(type.elementType[0])}>`;
+            return isInsideInstanceof() ? `Promise` : `Promise<${this.convert(type.elementType[0])}>`;
         }
         throw new Error(`Unmapped container type ${idl.DebugUtils.debugPrintType(type)}`);
     }
@@ -108,7 +105,7 @@ export class TSTypeNameConvertor {
     }
     convertTypeReferenceAsImport(type, importClause) {
         var _a;
-        const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) ? `<${type.typeArguments.join(', ')}>` : "";
+        const maybeTypeArguments = ((_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.length) && !isInsideInstanceof() ? `<${type.typeArguments.join(', ')}>` : "";
         let decl = this.library.resolveTypeReference(type);
         if (decl)
             return `${decl.name}${maybeTypeArguments}`;
@@ -122,6 +119,9 @@ export class TSTypeNameConvertor {
                 if (idl.isCallback(decl)) {
                     return this.mapCallback(decl, type.typeArguments);
                 }
+                if (idl.isTypedef(decl)) {
+                    return this.convert(decl.type);
+                }
                 const entity = idl.getExtAttribute(decl, idl.IDLExtendedAttributes.Entity);
                 if (entity) {
                     const isTuple = entity === idl.IDLEntity.Tuple;
@@ -141,7 +141,10 @@ export class TSTypeNameConvertor {
                 decl = this.library.resolveTypeReference(maybeRestoredGeneric);
             }
             let typeSpec = type.name;
-            let typeArgs = (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : [];
+            let typeArgs = !isInsideInstanceof() || decl && idl.isCallback(decl)
+                // there is a bug with panda - if we're inside callback generics, we need to expand other generics too. So withInsideInstanceof is used
+                ? (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => withInsideInstanceof(false, () => this.convert(it)))) !== null && _b !== void 0 ? _b : []
+                : [];
             if (typeSpec === `Optional`)
                 return `${typeArgs} | undefined`;
             if (typeSpec === `Function`)
@@ -249,7 +252,7 @@ export class TSTypeNameConvertor {
         return name;
     }
     mapFunctionType(typeArgs) {
-        return `Function${typeArgs.length ? `<${typeArgs.join(",")}>` : ''}`;
+        return isInsideInstanceof() ? `Function` : `Function${typeArgs.length ? `<${typeArgs.join(",")}>` : ''}`;
     }
 }
 export class TSInteropArgConvertor {
@@ -257,6 +260,11 @@ export class TSInteropArgConvertor {
         return convertType(this, type);
     }
     convertContainer(type) {
+        switch (type.elementType[0]) {
+            case idl.IDLU8Type: return 'KUint8ArrayPtr';
+            case idl.IDLI32Type: return 'KInt32ArrayPtr';
+            case idl.IDLF32Type: return 'KFloat32ArrayPtr';
+        }
         throw new Error(`Cannot pass container types through interop`);
     }
     convertImport(type) {
@@ -276,13 +284,17 @@ export class TSInteropArgConvertor {
             case idl.IDLF64Type: return "KDouble";
             case idl.IDLNumberType: return 'number';
             case idl.IDLBigintType: return 'bigint';
-            case idl.IDLBooleanType:
+            case idl.IDLBooleanType: return 'boolean';
             case idl.IDLFunctionType: return 'KInt';
             case idl.IDLStringType: return 'KStringPtr';
             case idl.IDLBufferType: return 'ArrayBuffer';
+            case idl.IDLSerializerBuffer: return 'KSerializerBuffer';
+            case idl.IDLInteropReturnBufferType: return `KInteropReturnBuffer`;
+            case idl.IDLObjectType: return 'Object';
+            case idl.IDLAnyType: return "Object";
             case idl.IDLDate: return 'number';
+            case idl.IDLVoidType: return 'void';
             case idl.IDLUndefinedType:
-            case idl.IDLVoidType:
             case idl.IDLPointerType: return 'KPointer';
         }
         throw new Error(`Cannot pass primitive type ${type.name} through interop`);

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

@@ -1,8 +1,9 @@
 import { Language } from "../Language";
 import { LibraryInterface } from "../LibraryInterface";
+import { PeerLibrary } from "../peer-generation/PeerLibrary";
 import { LanguageWriter } from "./LanguageWriter";
-import { TypeConvertor } from "./nameConvertor";
+import { IdlNameConvertor } from "./nameConvertor";
 export * from "./nameConvertor";
-export declare function createLanguageWriter(language: Language, library: LibraryInterface): LanguageWriter;
-export declare function createInteropArgConvertor(language: Language): TypeConvertor<string>;
+export declare function createLanguageWriter(language: Language, library: LibraryInterface, nameConvertor?: IdlNameConvertor): LanguageWriter;
+export declare function createInteropArgConvertor(language: Language, library: PeerLibrary): IdlNameConvertor;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,11 +1,10 @@
 import { IndentedPrinter } from "../IndentedPrinter";
 import { Language } from "../Language";
 import { PrimitiveTypesInstance } from "../peer-generation/PrimitiveType";
-import { createEmptyReferenceResolver } from "../peer-generation/ReferenceResolver";
 import { CJIDLTypeToForeignStringConvertor, CJInteropArgConvertor, CJTypeNameConvertor } from "./convertors/CJConvertors";
 import { CppInteropArgConvertor, CppConvertor } from "./convertors/CppConvertors";
 import { ETSInteropArgConvertor, ETSTypeNameConvertor } from "./convertors/ETSConvertors";
-import { KotlinCInteropArgConvertor, KotlinTypeNameConvertor } from "./convertors/KotlinConvertors";
+import { KotlinTypeNameConvertor } from "./convertors/KotlinConvertors";
 import { TSInteropArgConvertor, TSTypeNameConvertor } from "./convertors/TSConvertors";
 import { CJLanguageWriter } from "./writers/CJLanguageWriter";
 import { CppLanguageWriter } from "./writers/CppLanguageWriter";
@@ -13,26 +12,25 @@ import { ETSLanguageWriter } from "./writers/ETSLanguageWriter";
 import { KotlinLanguageWriter } from "./writers/KotlinLanguageWriter";
 import { TSLanguageWriter } from "./writers/TsLanguageWriter";
 export * from "./nameConvertor";
-export function createLanguageWriter(language, library) {
+export function createLanguageWriter(language, library, nameConvertor) {
     const printer = new IndentedPrinter();
     switch (language) {
-        case Language.TS: return new TSLanguageWriter(printer, library, new TSTypeNameConvertor(library));
-        case Language.ARKTS: return new ETSLanguageWriter(printer, library, new ETSTypeNameConvertor(library), new CppConvertor(library));
-        case Language.CPP: return new CppLanguageWriter(printer, library, new CppConvertor(library), PrimitiveTypesInstance);
-        case Language.CJ: return new CJLanguageWriter(printer, library, new CJTypeNameConvertor(library), new CJIDLTypeToForeignStringConvertor(library));
-        case Language.KOTLIN: return new KotlinLanguageWriter(printer, library, new KotlinTypeNameConvertor(library));
+        case Language.TS: return new TSLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new TSTypeNameConvertor(library));
+        case Language.ARKTS: return new ETSLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new ETSTypeNameConvertor(library), new CppConvertor(library));
+        case Language.CPP: return new CppLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new CppConvertor(library), PrimitiveTypesInstance);
+        case Language.CJ: return new CJLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new CJTypeNameConvertor(library), new CJIDLTypeToForeignStringConvertor(library));
+        case Language.KOTLIN: return new KotlinLanguageWriter(printer, library, nameConvertor !== null && nameConvertor !== void 0 ? nameConvertor : new KotlinTypeNameConvertor(library));
         default: throw new Error(`Language ${language.toString()} is not supported`);
     }
 }
-export function createInteropArgConvertor(language) {
+export function createInteropArgConvertor(language, library) {
     switch (language) {
         case Language.TS: return new TSInteropArgConvertor();
         case Language.ARKTS: return new ETSInteropArgConvertor();
         case Language.CPP: return CppInteropArgConvertor.INSTANCE;
         case Language.CJ: return new CJInteropArgConvertor();
-        case Language.KOTLIN: return new KotlinCInteropArgConvertor();
+        case Language.KOTLIN: return new KotlinTypeNameConvertor(library);
     }
     throw new Error(`InteropArgConvertor for language ${language} not implemented`);
 }
-const EmptyReferenceResolver = createEmptyReferenceResolver();
 //# sourceMappingURL=index.js.map

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

@@ -27,4 +27,6 @@ export declare function convertDeclaration<T>(convertor: DeclarationConvertor<T>
 export interface NodeConvertor<T> extends TypeConvertor<T>, DeclarationConvertor<T> {
 }
 export declare function convertNode<T>(convertor: NodeConvertor<T>, node: idl.IDLNode): T;
+export declare function isInsideInstanceof(): boolean;
+export declare function withInsideInstanceof<T>(isInsideInstanceof: boolean, op: () => T): T;
 //# sourceMappingURL=nameConvertor.d.ts.map

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

@@ -62,4 +62,15 @@ export function convertNode(convertor, node) {
         return convertType(convertor, node);
     throw new Error(`Unknown node type ${idl.IDLKind[node.kind]}`);
 }
+let _isInsideInstanceof = false;
+export function isInsideInstanceof() {
+    return _isInsideInstanceof;
+}
+export function withInsideInstanceof(isInsideInstanceof, op) {
+    const prevIsInsideInstanceof = _isInsideInstanceof;
+    _isInsideInstanceof = isInsideInstanceof;
+    const result = op();
+    _isInsideInstanceof = prevIsInsideInstanceof;
+    return result;
+}
 //# sourceMappingURL=nameConvertor.js.map

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

@@ -386,7 +386,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         return createReferenceType('Tag');
     }
     getRuntimeType() {
-        return createReferenceType(`RuntimeType`);
+        return createReferenceType(`idlize.stdlib.RuntimeType`);
     }
     makeTupleAssign(receiver, tupleFields) {
         const statements = tupleFields.map((field, index) => {

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

@@ -1,7 +1,7 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature } from "../LanguageWriter";
 import { TSLanguageWriter } from "./TsLanguageWriter";
-import { IDLEnum, IDLType } from '../../idl';
+import { IDLType } from '../../idl';
 import { ArgConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
 import { IdlNameConvertor } from "../nameConvertor";
@@ -23,25 +23,14 @@ export declare class EtsAssignStatement implements LanguageStatement {
     constructor(variableName: string, type: IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions | undefined);
     write(writer: LanguageWriter): void;
 }
-export declare class ArkTSEnumEntityStatement implements LanguageStatement {
-    private readonly enumEntity;
-    private readonly options;
-    constructor(enumEntity: IDLEnum, options: {
-        isExport: boolean;
-        isDeclare: boolean;
-    });
-    write(writer: LanguageWriter): void;
-}
 export declare class ETSLambdaExpression extends LambdaExpression {
     private convertor;
     constructor(writer: LanguageWriter, convertor: IdlNameConvertor, signature: MethodSignature, resolver: ReferenceResolver, body?: LanguageStatement[]);
     protected get statementHasSemicolon(): boolean;
     asString(): string;
 }
-export declare function generateTypeCheckerName(typeName: string): string;
 export declare function generateEnumToNumericName(entry: idl.IDLEntry): string;
 export declare function generateEnumFromNumericName(entry: idl.IDLEntry): string;
-export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, arrayConvertor: IdlNameConvertor);
@@ -62,10 +51,6 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
-    makeEnumEntity(enumEntity: IDLEnum, options: {
-        isExport: boolean;
-        isDeclare?: boolean;
-    }): LanguageStatement;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     isQuickType(type: IDLType): boolean;
     writeNativeMethodDeclaration(method: Method): void;
@@ -74,12 +59,7 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
-    typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
-    makeTypeCast(value: LanguageExpression, type: idl.IDLType, options?: MakeCastOptions): LanguageExpression;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
-    static _isUseTypeChecker: boolean;
-    static get isUseTypeChecker(): boolean;
-    static useTypeChecker<T>(isUseTypeChecker: boolean, op: () => T): T;
+    instanceOf(value: string, type: idl.IDLType): 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

@@ -15,11 +15,10 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { BlockStatement, LambdaExpression, MethodModifier } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
-import { getExtAttribute, IDLThisType } from '../../idl';
+import { IDLThisType } from '../../idl';
 import { AggregateConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
-import { convertDeclaration } from "../nameConvertor";
-import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
+import { withInsideInstanceof } from "../nameConvertor";
 import { Language } from "../../Language";
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
@@ -56,7 +55,7 @@ export class EtsAssignStatement {
             const typeClause = this.type !== undefined ? `: ${writer.getNodeName(this.type)}` : '';
             const maybeAssign = this.expression !== undefined ? " = " : "";
             const initValue = this.expression !== undefined ? this.expression : writer.makeString("");
-            writer.print(`${this.isConst ? "const" : "let"} ${this.variableName} ${typeClause}${maybeAssign}${initValue.asString()}`);
+            writer.print(`${this.isConst ? "const" : "let"} ${this.variableName}${typeClause}${maybeAssign}${initValue.asString()}`);
         }
         else {
             const receiver = (_a = this.options) === null || _a === void 0 ? void 0 : _a.receiver;
@@ -82,46 +81,6 @@ class ArkTSMapForEachStatement {
         writer.print(`}`);
     }
 }
-export class ArkTSEnumEntityStatement {
-    constructor(enumEntity, options) {
-        this.enumEntity = enumEntity;
-        this.options = options;
-    }
-    write(writer) {
-        let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
-        enumName = enumName.split('.').at(-1);
-        const members = this.enumEntity.elements
-            .flatMap((member, index) => {
-            var _a;
-            const initText = (_a = member.initializer) !== null && _a !== void 0 ? _a : index;
-            const isTypeString = typeof initText !== "number";
-            const originalName = getExtAttribute(member, idl.IDLExtendedAttributes.OriginalEnumMemberName);
-            const res = [{
-                    name: member.name,
-                    alias: undefined,
-                    stringId: isTypeString ? initText : undefined,
-                    numberId: initText
-                }];
-            if (originalName !== undefined) {
-                res.push({
-                    name: originalName,
-                    alias: undefined,
-                    stringId: isTypeString ? initText : undefined,
-                    numberId: initText
-                });
-                //TODO: enums do not support member aliases
-                // res.push({
-                //     name: originalName,
-                //     alias: member.name,
-                //     stringId: undefined,
-                //     numberId: initText as number
-                // })
-            }
-            return res;
-        });
-        writer.writeEnum(enumName, members, { isExport: this.options.isExport, isDeclare: this.options.isDeclare });
-    }
-}
 export class ETSLambdaExpression extends LambdaExpression {
     constructor(writer, convertor, signature, resolver, body) {
         super(writer, signature, resolver, body);
@@ -149,12 +108,6 @@ export class ETSLambdaExpression extends LambdaExpression {
 ////////////////////////////////////////////////////////////////
 //                           UTILS                            //
 ////////////////////////////////////////////////////////////////
-export function generateTypeCheckerName(typeName) {
-    return "is" + typeName
-        .replaceAll('[]', 'BracketsArray')
-        .replaceAll(/<.*$/g, '') // delete type arguments
-        .replaceAll('.', '_');
-}
 export function generateEnumToNumericName(entry) {
     const typeName = idl.getQualifiedName(entry, "namespace.name").split('.').join('_');
     return `${typeName}_ToNumeric`;
@@ -163,10 +116,6 @@ export function generateEnumFromNumericName(entry) {
     const typeName = idl.getQualifiedName(entry, "namespace.name").split('.').join('_');
     return `${typeName}_FromNumeric`;
 }
-export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
-    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
-    ]);
-}
 ////////////////////////////////////////////////////////////////
 //                           WRITER                           //
 ////////////////////////////////////////////////////////////////
@@ -204,18 +153,22 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return this.makeString(`${value} as ${type}`);
     }
     i32FromEnum(value, enumEntry) {
-        if (ETSLanguageWriter.isUseTypeChecker) {
-            return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumEntry), [value]);
+        if (idl.isStringEnum(enumEntry)) {
+            let extractorStatement = this.makeMethodCall(value.asString(), 'getOrdinal', []);
+            if (enumEntry.elements.some(it => idl.hasExtAttribute(it, idl.IDLExtendedAttributes.OriginalEnumMemberName))) {
+                extractorStatement = this.makeNaryOp('%', [
+                    extractorStatement,
+                    this.makeString(enumEntry.elements.length.toString())
+                ]);
+            }
+            return extractorStatement;
+        }
+        else {
+            return this.makeMethodCall(value.asString(), 'valueOf', []);
         }
-        return idl.isStringEnum(enumEntry)
-            ? this.makeMethodCall(value.asString(), 'getOrdinal', [])
-            : this.makeMethodCall(value.asString(), 'valueOf', []);
     }
     enumFromI32(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        if (ETSLanguageWriter.isUseTypeChecker) {
-            return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumEntry), [value]);
-        }
         return idl.isStringEnum(enumEntry)
             ? this.makeString(`${enumName}.values()[${value.asString()}]`)
             : this.makeMethodCall(enumName, 'fromValue', [value]);
@@ -227,7 +180,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
             || convertor instanceof CustomTypeConvertor) {
             return this.instanceOf(value, convertor.idlType);
         }
-        return this.makeString(`${value} instanceof ${convertor.targetType(this)}`);
+        return this.makeString(`${value} instanceof ${withInsideInstanceof(true, () => convertor.targetType(this))}`);
     }
     makeValueFromOption(value, destinationConvertor) {
         if (idl.isEnum(this.resolver.toDeclaration(destinationConvertor.nativeType()))) {
@@ -235,12 +188,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         return super.makeValueFromOption(value, destinationConvertor);
     }
-    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),
-        });
-    }
     writeMethodCall(receiver, method, params, nullable = false) {
         // ArkTS does not support - 'this.?'
         super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
@@ -266,15 +213,16 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return super.makeNaryOp('==', args);
     }
     discriminate(value, index, type, runtimeTypes) {
-        // work around ArkTS compiler bugs
-        if (idl.IDLContainerUtils.isSequence(type)) {
-            const arrayTypeName = this.arrayConvertor.convert(type);
-            return `TypeChecker.${generateTypeCheckerName(arrayTypeName)}(${value})`;
-        }
-        if (this.getNodeName(type) === "DragPreviewMode") {
-            return `TypeChecker.isDragPreviewMode(${value})`;
-        }
-        return `${value} instanceof ${this.getNodeName(type)}`;
+        return `${value} instanceof ${withInsideInstanceof(true, () => {
+            let typeName = this.getNodeName(type);
+            if (idl.isReferenceType(type)) {
+                const decl = this.resolver.resolveTypeReference(type);
+                if (decl && idl.isInterface(decl) && decl.subkind == idl.IDLInterfaceSubkind.Tuple) {
+                    typeName = "Tuple";
+                }
+            }
+            return typeName;
+        })}`;
     }
     castToInt(value, bitness) {
         // This fix is used to avoid unnecessary writeInt8(value as int32) call, which is generated if value is already an int32
@@ -284,50 +232,23 @@ export class ETSLanguageWriter extends TSLanguageWriter {
             return `(${value}).toChar()`;
         return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
-    castToBoolean(value) { return `${value} ? 1 : 0`; }
-    typeInstanceOf(type, value, members) {
-        if (!members || members.length === 0) {
-            throw new Error("At least one member needs to provided to pass it to TypeChecker!");
-        }
-        const prop = members[0];
-        // Use the same typeInstanceOf<T>(...) method to compile the ETS code by two compilers ArkTS and TS
-        return this.makeString(`TypeChecker.typeInstanceOf<${this.getNodeName(type)}>(value, "${prop}")`);
-    }
-    makeTypeCast(value, type, options) {
-        return this.makeString(`TypeChecker.typeCast<${this.getNodeName(type)}>(value)`);
-    }
+    castToBoolean(value) { return `${value} ? true : false`; }
     makeCast(value, node, options) {
         var _a;
         if (node === idl.IDLI64Type)
-            return this.makeMethodCall(value.asString(), `toLong`, []);
+            return this.makeMethodCall(value.asString() + '!', `toLong`, []);
         if (node === idl.IDLI32Type)
-            return this.makeMethodCall(value.asString(), `toInt`, []);
+            return this.makeMethodCall(value.asString() + '!', `toInt`, []);
         if (node === idl.IDLI8Type)
-            return this.makeMethodCall(value.asString(), `toByte`, []);
+            return this.makeMethodCall(value.asString() + '!', `toByte`, []);
         if (node === idl.IDLF64Type)
-            return this.makeMethodCall(value.asString(), `toDouble`, []);
+            return this.makeMethodCall(value.asString() + '!', `toDouble`, []);
         if (node === idl.IDLF32Type)
-            return this.makeMethodCall(value.asString(), `toFloat`, []);
+            return this.makeMethodCall(value.asString() + '!', `toFloat`, []);
         return new TSCastExpression(value, `${this.getNodeName(node)}`, (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
-    static get isUseTypeChecker() { return this._isUseTypeChecker; }
-    static useTypeChecker(isUseTypeChecker, op) {
-        const prevIsUse = this.isReferenceRelativeToNamespaces;
-        this._isUseTypeChecker = isUseTypeChecker;
-        const result = op();
-        this._isUseTypeChecker = prevIsUse;
-        return result;
+    instanceOf(value, type) {
+        return this.makeString(this.discriminate(value, -1, type, []));
     }
 }
-ETSLanguageWriter._isUseTypeChecker = true;
-function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
-    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
-        ...allFields.map(it => {
-            return writer.makeString(duplicates.has(it) ? "true" : "false");
-        })
-    ]);
-}
-export function makeEnumTypeCheckerCall(valueAccessor, enumName, writer) {
-    return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(enumName), [writer.makeString(valueAccessor)]);
-}
 //# sourceMappingURL=ETSLanguageWriter.js.map

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

@@ -78,6 +78,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     writePrintLog(message: string): void;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
+    instanceOf(value: string, type: idl.IDLType): LanguageExpression;
     typeInstanceOf(type: idl.IDLEntry, value: string, members?: string[]): LanguageExpression;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     makeUndefined(): LanguageExpression;
@@ -100,5 +101,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;
     discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
+    private writingClassBody;
+    classOp(op: () => void): void;
 }
 //# sourceMappingURL=TsLanguageWriter.d.ts.map