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

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 } 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,9 @@ 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)
+                ? (_b = (_a = type.typeArguments) === null || _a === void 0 ? void 0 : _a.map(it => this.convert(it))) !== null && _b !== void 0 ? _b : []
+                : [];
             if (typeSpec === `Optional`)
                 return `${typeArgs} | undefined`;
             if (typeSpec === `Function`)
@@ -249,7 +251,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 +259,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 +283,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

@@ -38,10 +38,8 @@ export declare class ETSLambdaExpression extends LambdaExpression {
     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);
@@ -74,12 +72,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

@@ -18,7 +18,7 @@ import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
 import { getExtAttribute, IDLThisType } from '../../idl';
 import { AggregateConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
-import { convertDeclaration } from "../nameConvertor";
+import { convertDeclaration, withInsideInstanceof } from "../nameConvertor";
 import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
 import { Language } from "../../Language";
 ////////////////////////////////////////////////////////////////
@@ -56,7 +56,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;
@@ -90,35 +90,30 @@ export class ArkTSEnumEntityStatement {
     write(writer) {
         let enumName = convertDeclaration(createDeclarationNameConvertor(Language.ARKTS), this.enumEntity);
         enumName = enumName.split('.').at(-1);
-        const members = this.enumEntity.elements
-            .flatMap((member, index) => {
+        const correctStyleNames = [];
+        const originalStyleNames = [];
+        this.enumEntity.elements.forEach((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;
+            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
+            });
         });
+        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 });
     }
 }
@@ -149,12 +144,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 +152,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 +189,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 +216,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()))) {
@@ -266,15 +255,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 +274,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

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

@@ -16,7 +16,7 @@ import * as idl from '../../idl';
 import { isOptionalType } from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { ACCESS_MODIFIERS_SET, AssignStatement, BlockStatement, DelegationType, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { rightmostIndexOf } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
@@ -67,7 +67,7 @@ class TSThrowErrorStatement {
         this.message = message;
     }
     write(writer) {
-        writer.print(`throw new Error("${this.message}")`);
+        writer.print(`throw new Error('${this.message}')`);
     }
 }
 export class TSReturnStatement extends ReturnStatement {
@@ -121,6 +121,7 @@ export class TsTupleAllocStatement {
 export class TSLanguageWriter extends LanguageWriter {
     constructor(printer, resolver, typeConvertor, language = Language.TS) {
         super(printer, resolver, language);
+        this.writingClassBody = false;
         this.typeConvertor = typeConvertor;
     }
     maybeSemicolon() { return ""; }
@@ -159,7 +160,7 @@ export class TSLanguageWriter extends LanguageWriter {
         let abstractClause = isAbstract ? ` abstract` : '';
         this.printer.print(`export${declaredClause}${abstractClause} class ${name}${genericsClause}${extendsClause}${implementsClause} {`);
         this.pushIndent();
-        op(this);
+        this.classOp(() => op(this));
         this.popIndent();
         this.printer.print(`}`);
     }
@@ -201,7 +202,7 @@ export class TSLanguageWriter extends LanguageWriter {
                 value = member.alias;
             }
             else {
-                value = `${member.stringId != undefined ? `"${member.stringId}"` : `${member.numberId}`}`;
+                value = `${member.stringId != undefined ? `'${member.stringId}'` : `${member.numberId}`}`;
             }
             const maybeComma = index < members.length - 1 ? "," : "";
             this.printer.print(`${member.name} = ${value}${maybeComma}`);
@@ -210,6 +211,11 @@ export class TSLanguageWriter extends LanguageWriter {
         this.printer.print("}");
     }
     writeFieldDeclaration(name, type, modifiers, optional, initExpr) {
+        var _a;
+        if (this.writingClassBody && !(modifiers === null || modifiers === void 0 ? void 0 : modifiers.some(m => ACCESS_MODIFIERS_SET.has(m)))) {
+            modifiers = (_a = modifiers === null || modifiers === void 0 ? void 0 : modifiers.slice()) !== null && _a !== void 0 ? _a : [];
+            modifiers.unshift(FieldModifier.PUBLIC);
+        }
         let prefix = this.makeFieldModifiersList(modifiers);
         if (prefix)
             prefix += " ";
@@ -300,7 +306,7 @@ export class TSLanguageWriter extends LanguageWriter {
         for (let i = 0; i < importedFeatures.length; i++) {
             importNodes.push(importedFeatures[i] + (aliases[i] ? ` as ${aliases[i]}` : ``));
         }
-        this.writeExpressionStatement(this.makeString(`import { ${importNodes.join(', ')} } from "${moduleName}"`));
+        this.writeExpressionStatement(this.makeString(`import { ${importNodes.join(', ')} } from '${moduleName}'`));
     }
     writeDeclaration(name, signature, needReturn, needBracket, modifiers, generics) {
         let prefix = !modifiers ? undefined : this.supportedModifiers
@@ -354,6 +360,11 @@ export class TSLanguageWriter extends LanguageWriter {
         var _a;
         return new TSCastExpression(value, this.getNodeName(node), (_a = options === null || options === void 0 ? void 0 : options.unsafe) !== null && _a !== void 0 ? _a : false);
     }
+    instanceOf(value, type) {
+        return idl.IDLContainerUtils.isSequence(type)
+            ? this.makeString(`Array.isArray(${value})`)
+            : super.instanceOf(value, type);
+    }
     typeInstanceOf(type, value, members) {
         if (idl.isInterface(type)) {
             if (idl.isInterfaceSubkind(type)) {
@@ -440,16 +451,22 @@ export class TSLanguageWriter extends LanguageWriter {
         }
         return this.makeString(`${value.asString()}.valueOf()`);
     }
-    castToBoolean(value) { return `+${value}`; }
+    castToBoolean(value) { return `!!${value}`; }
     makeCallIsObject(value) {
         return this.makeString(`${value} instanceof Object`);
     }
     escapeKeyword(keyword) {
-        return TSKeywords.has(keyword) ? keyword + "_" : keyword;
+        return TSKeywords.has(keyword) ? keyword + "Val" : keyword;
     }
     discriminate(value, index, type, runtimeTypes) {
         const runtimeTypeList = runtimeTypes.map(ty => "RuntimeType." + RuntimeType[ty]).join(", ");
         return `[${runtimeTypeList}].includes(runtimeType(${value}))`;
     }
+    classOp(op) {
+        const old = this.writingClassBody;
+        this.writingClassBody = true;
+        op();
+        this.writingClassBody = old;
+    }
 }
 //# sourceMappingURL=TsLanguageWriter.js.map