@idlizer/core 2.1.5 → 2.1.7

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

@@ -130,16 +130,17 @@ export class ETSLambdaExpression extends LambdaExpression {
 //                           UTILS                            //
 ////////////////////////////////////////////////////////////////
 export function generateTypeCheckerName(typeName) {
-    typeName = typeName.replaceAll('[]', 'BracketsArray')
-        .replaceAll('.', ''); // Todo: hack for namespaces
+    typeName = typeName
+        .replaceAll('[]', 'BracketsArray')
+        .split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
     return `is${typeName.replaceAll('[]', 'Brackets')}`;
 }
 export function generateEnumToNumericName(typeName) {
-    typeName = typeName.split(".").join("_");
+    typeName = typeName.split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
     return `${typeName}_ToNumeric`;
 }
 export function generateEnumFromNumericName(typeName) {
-    typeName = typeName.split(".").join("_");
+    typeName = typeName.split('.').at(-1); // Todo: hack for namespaces. Remove when ready to use FQNames
     return `${typeName}_FromNumeric`;
 }
 export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
@@ -180,12 +181,22 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return this.makeString(`${value} as ${type}`);
     }
     i32FromEnum(value, enumEntry) {
-        const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumName), [value]);
+        if (ETSLanguageWriter.isUseTypeChecker) {
+            const enumName = this.getNodeName(enumEntry);
+            return this.makeMethodCall('TypeChecker', generateEnumToNumericName(enumName), [value]);
+        }
+        return idl.isStringEnum(enumEntry)
+            ? this.makeMethodCall(value.asString(), 'getOrdinal', [])
+            : this.makeMethodCall(value.asString(), 'valueOf', []);
     }
     enumFromI32(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumName), [value]);
+        if (ETSLanguageWriter.isUseTypeChecker) {
+            return this.makeMethodCall('TypeChecker', generateEnumFromNumericName(enumName), [value]);
+        }
+        return idl.isStringEnum(enumEntry)
+            ? this.makeString(`${enumName}.values()[${value.asString()}]`)
+            : this.makeMethodCall(enumName, 'fromValue', [value]);
     }
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         if (convertor instanceof AggregateConvertor
@@ -269,6 +280,11 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // ])
     }
     castToInt(value, bitness) {
+        // This fix is used to avoid unnecessary writeInt8(value as int32) call, which is generated if value is already an int32
+        // The explicit cast forces ui2abc to call valueOf on an int, which fails the compilation
+        // TODO Fix this cast
+        if (bitness === 8)
+            return value;
         return `${value} as int32`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? 1 : 0`; }
@@ -308,7 +324,16 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         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);
     }
+    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;
+    }
 }
+ETSLanguageWriter._isUseTypeChecker = true;
 function makeInterfaceTypeCheckerCall(valueAccessor, interfaceName, allFields, duplicates, writer) {
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(interfaceName), [writer.makeString(valueAccessor),
         ...allFields.map(it => {

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

@@ -32,15 +32,18 @@ export declare class TSLanguageWriter extends LanguageWriter {
     protected typeConvertor: IdlNameConvertor;
     constructor(printer: IndentedPrinter, resolver: ReferenceResolver, typeConvertor: IdlNameConvertor, language?: Language);
     maybeSemicolon(): string;
-    pushNamespace(namespace: string, ident?: boolean): void;
+    pushNamespace(namespace: string, options: {
+        ident: boolean;
+        isDeclared?: boolean;
+    }): void;
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     getNodeName(type: idl.IDLNode): string;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isAbstract?: boolean): void;
     writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[], isDeclared?: boolean): void;
-    writeFunctionDeclaration(name: string, signature: MethodSignature): void;
-    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void): void;
+    writeFunctionDeclaration(name: string, signature: MethodSignature, generics?: string[]): void;
+    writeFunctionImplementation(name: string, signature: MethodSignature, op: (writer: this) => void, generics?: string[]): void;
     private generateFunctionDeclaration;
     writeEnum(name: string, members: {
         name: string;

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

@@ -124,10 +124,11 @@ export class TSLanguageWriter extends LanguageWriter {
         this.typeConvertor = typeConvertor;
     }
     maybeSemicolon() { return ""; }
-    pushNamespace(namespace, ident = true) {
+    pushNamespace(namespace, options) {
         this.namespaceStack.push(namespace);
-        this.print(`export namespace ${namespace} {`);
-        if (ident)
+        const declaredPrefix = options.isDeclared ? "declare " : "";
+        this.print(`export ${declaredPrefix}namespace ${namespace} {`);
+        if (options.ident)
             this.pushIndent();
     }
     fork(options) {
@@ -165,24 +166,25 @@ export class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeFunctionDeclaration(name, signature) {
-        this.printer.print(this.generateFunctionDeclaration(name, signature));
+    writeFunctionDeclaration(name, signature, generics) {
+        this.printer.print(this.generateFunctionDeclaration(name, signature, generics));
     }
-    writeFunctionImplementation(name, signature, op) {
-        this.printer.print(`${this.generateFunctionDeclaration(name, signature)} {`);
+    writeFunctionImplementation(name, signature, op, generics) {
+        this.printer.print(`${this.generateFunctionDeclaration(name, signature, generics)} {`);
         this.printer.pushIndent();
         op(this);
         this.printer.popIndent();
         this.printer.print('}');
     }
-    generateFunctionDeclaration(name, signature) {
+    generateFunctionDeclaration(name, signature, generics) {
         const rightmostRegularParameterIndex = rightmostIndexOf(signature.args, it => !isOptionalType(it));
         const args = signature.args.map((it, index) => {
             const optionalToken = idl.isOptionalType(it) && index > rightmostRegularParameterIndex ? '?' : '';
             return `${signature.argName(index)}${optionalToken}: ${this.getNodeName(it)}`;
         });
         const returnType = this.getNodeName(signature.returnType);
-        return `export function ${name}(${args.join(", ")}): ${returnType}`;
+        const typeParams = generics && generics.length ? '<' + (generics === null || generics === void 0 ? void 0 : generics.join(', ')) + '>' : '';
+        return `export function ${name}${typeParams}(${args.join(", ")}): ${returnType}`;
     }
     writeEnum(name, members, options) {
         this.printer.print(`${options.isExport ? "export " : ""}${options.isDeclare ? "declare " : ""}enum ${name} {`);