@idlizer/core 2.0.41 → 2.1.0

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

@@ -1,5 +1,5 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
 import { TSLanguageWriter } from "./TsLanguageWriter";
 import { IDLEnum, IDLType } from '../../idl';
 import { ArgConvertor } from "../ArgConvertors";
@@ -28,6 +28,8 @@ export declare class ETSLambdaExpression extends LambdaExpression {
     asString(): string;
 }
 export declare function generateTypeCheckerName(typeName: string): string;
+export declare function generateEnumToOrdinalName(typeName: string): string;
+export declare function generateEnumFromOrdinalName(typeName: string): string;
 export declare function makeArrayTypeCheckCall(valueAccessor: string, typeName: string, writer: LanguageWriter): LanguageExpression;
 export declare class ETSLanguageWriter extends TSLanguageWriter {
     private arrayConvertor;
@@ -35,17 +37,15 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
-    writeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
     makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
     get supportedModifiers(): MethodModifier[];
-    makeUnsafeCast(convertor: ArgConvertor, param: string): string;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index?: number): LanguageExpression;
     enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
     makeDiscriminatorFromFields(convertor: {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
@@ -54,8 +54,9 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     makeEnumEntity(enumEntity: IDLEnum, isExport: boolean): LanguageStatement;
     getObjectAccessor(convertor: ArgConvertor, value: string, args?: ObjectArgs): string;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
+    isQuickType(type: IDLType): boolean;
+    writeNativeMethodDeclaration(method: Method): void;
     writeProperty(propName: string, propType: IDLType): void;
-    makeEnumCast(value: string, _unsafe: boolean, convertor: ArgConvertor | undefined): string;
     makeUnionVariantCondition(convertor: ArgConvertor, valueName: string, valueType: string, type: string, convertorIndex: number, runtimeTypeIndex: number): LanguageExpression;
     makeCastCustomObject(customName: string, isGenericType: boolean): LanguageExpression;
     makeHasOwnProperty(value: string, valueTypeName: string, property: string, propertyTypeName: string): LanguageExpression;

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

@@ -15,14 +15,13 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { LambdaExpression, MethodModifier } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
-import { getExtAttribute, IDLI32Type, IDLThisType } from '../../idl';
-import { AggregateConvertor, ArrayConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor, OptionConvertor, UnionConvertor } from "../ArgConvertors";
+import { getExtAttribute, IDLThisType } from '../../idl';
+import { AggregateConvertor, ArrayConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor, OptionConvertor, UnionConvertor, BufferConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
 import { convertDeclaration } from "../nameConvertor";
 import { createDeclarationNameConvertor } from "../../peer-generation/idl/IdlNameConvertor";
 import { Language } from "../../Language";
 import { RuntimeType } from "../common";
-import { throwException } from "../../util";
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
@@ -138,6 +137,14 @@ export function generateTypeCheckerName(typeName) {
         .replaceAll('.', ''); // Todo: hack for namespaces
     return `is${typeName.replaceAll('[]', 'Brackets')}`;
 }
+export function generateEnumToOrdinalName(typeName) {
+    typeName = typeName.split(".").join("_");
+    return `${typeName}_ToOrdinal`;
+}
+export function generateEnumFromOrdinalName(typeName) {
+    typeName = typeName.split(".").join("_");
+    return `${typeName}_FromOrdinal`;
+}
 export function makeArrayTypeCheckCall(valueAccessor, typeName, writer) {
     return writer.makeMethodCall("TypeChecker", generateTypeCheckerName(typeName), [writer.makeString(valueAccessor)
     ]);
@@ -154,12 +161,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         var _a;
         return new ETSLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
     }
-    writeNativeMethodDeclaration(name, signature) {
-        if (signature.returnType === IDLThisType) {
-            throw new Error('static method can not return this!');
-        }
-        this.writeMethodDeclaration(name, signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
-    }
     makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
         return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst);
     }
@@ -175,13 +176,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     get supportedModifiers() {
         return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.NATIVE, MethodModifier.STATIC];
     }
-    makeUnsafeCast(convertor, param) {
-        if (idl.isEnum(convertor.idlType) && !param.endsWith(".value")) {
-            const isStringEnum = idl.isStringEnum(convertor.idlType);
-            return `(${param} as ${this.typeConvertor.convert(convertor.idlType)}).${isStringEnum ? 'ordinal' : 'value'}`;
-        }
-        return super.makeUnsafeCast(convertor, param);
-    }
     runtimeType(param, valueType, value) {
         super.runtimeType(param, valueType, value);
     }
@@ -190,10 +184,11 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     }
     enumFromOrdinal(value, enumEntry) {
         const enumName = this.getNodeName(enumEntry);
-        return this.makeString(`${value.asString()} as ${enumName}`);
+        return this.makeMethodCall('TypeChecker', generateEnumFromOrdinalName(enumName), [this.makeString(value.asString())]);
     }
-    ordinalFromEnum(value, _) {
-        return this.makeCast(this.makeString(`${value.asString()}`), IDLI32Type);
+    ordinalFromEnum(value, enumEntry) {
+        const enumName = this.getNodeName(enumEntry);
+        return this.makeMethodCall('TypeChecker', generateEnumToOrdinalName(enumName), [this.makeString(value.asString())]);
     }
     makeDiscriminatorFromFields(convertor, value, accessors, duplicates) {
         if (convertor instanceof AggregateConvertor
@@ -223,19 +218,17 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // ArkTS does not support - 'this.?'
         super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
     }
-    writeProperty(propName, propType) {
-        throw new Error("writeProperty for ArkTS is not implemented yet.");
+    isQuickType(type) {
+        return idl.asPromise(type) == undefined;
     }
-    makeEnumCast(value, _unsafe, convertor) {
-        if (convertor === undefined) {
-            throwException(`The makeEnumCast function required EnumConvertor`);
-        }
-        const decl = this.resolver.toDeclaration(convertor.nativeType());
-        if (!idl.isEnum(decl)) {
-            throwException(`Declaration type must be Enum`);
+    writeNativeMethodDeclaration(method) {
+        if (method.signature.returnType === IDLThisType) {
+            throw new Error('static method can not return this!');
         }
-        // ((value as Axis) as int) - in case when Axis was casted to Object in Map<Axis, Smth>
-        return this.makeCast(this.makeCast(this.makeString(value), convertor.idlType), IDLI32Type).asString();
+        this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
+    }
+    writeProperty(propName, propType) {
+        throw new Error("writeProperty for ArkTS is not implemented yet.");
     }
     makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
         if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
@@ -289,6 +282,9 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         if (convertor instanceof InterfaceConvertor || convertor instanceof MaterializedClassConvertor) {
             return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), convertor.declaration.properties.filter(it => !it.isStatic).map(it => it.name), duplicateMembers, this);
         }
+        if (convertor instanceof BufferConvertor) {
+            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), [], new Set(), this);
+        }
         if (convertor instanceof AggregateConvertor) {
             return makeInterfaceTypeCheckerCall(value, convertor.aliasName !== undefined ? convertor.aliasName : this.getNodeName(convertor.idlType), convertor.members.map(it => it[0]), duplicateMembers, this);
         }

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

@@ -35,10 +35,10 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
     writeClass(name: string, op: (writer: this) => void, superClass?: string, interfaces?: string[], generics?: string[], isDeclared?: boolean, isExport?: boolean): void;
-    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[]): void;
+    writeInterface(name: string, op: (writer: this) => void, superInterfaces?: string[], generics?: string[]): void;
     writeMethodCall(receiver: string, method: string, params: string[], nullable?: boolean): void;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    writeNativeMethodDeclaration(name: string, signature: MethodSignature): void;
+    writeNativeMethodDeclaration(method: Method): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeProperty(propName: string, propType: idl.IDLType): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
@@ -78,7 +78,7 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     ordinalFromEnum(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
     makeValueFromOption(value: string): LanguageExpression;
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
-    makeEnumCast(enumName: string, _unsafe: boolean, _convertor: ArgConvertor | undefined): string;
+    makeEnumCast(_enumEntry: idl.IDLEnum, enumName: string): string;
     castToBoolean(value: string): string;
     makeLengthSerializer(serializer: string, value: string): LanguageStatement | undefined;
 }

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

@@ -116,7 +116,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeInterface(name, op, superInterfaces) {
+    writeInterface(name, op, superInterfaces, generics) {
         let extendsClause = superInterfaces ? ` extends ${superInterfaces.join(",")}` : '';
         this.printer.print(`interface ${name}${extendsClause} {`);
         this.pushIndent();
@@ -136,8 +136,8 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         let prefix = this.makeFieldModifiersList(modifiers);
         this.printer.print(`${prefix} ${(this.getNodeName(type))} ${name}${initExpr ? ` = ${initExpr.asString()}` : ""};`);
     }
-    writeNativeMethodDeclaration(name, signature) {
-        this.writeMethodDeclaration(name, signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
+    writeNativeMethodDeclaration(method) {
+        this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
     }
     writeConstructorImplementation(className, signature, op, superCall, modifiers) {
         this.printer.print(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') : ''} ${className}(${signature.args.map((it, index) => `${this.getNodeName(it)} ${signature.argName(index)}`).join(", ")}) {`);
@@ -267,7 +267,7 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     runtimeType(param, valueType, value) {
         this.writeStatement(this.makeAssign(valueType, undefined, this.makeRuntimeTypeGetterCall(value), false));
     }
-    makeEnumCast(enumName, _unsafe, _convertor) {
+    makeEnumCast(_enumEntry, enumName) {
         return `${enumName}.value`;
     }
     castToBoolean(value) { return value; }

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

@@ -38,7 +38,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     }): 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[], isDeclared?: 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;
     private generateFunctionDeclaration;
@@ -49,7 +49,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
         numberId: number;
     }[]): void;
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): void;
-    writeNativeMethodDeclaration(name: string, signature: MethodSignature, isNative?: boolean): void;
+    writeNativeMethodDeclaration(method: Method): void;
     writeMethodDeclaration(name: string, signature: MethodSignature, modifiers?: MethodModifier[]): void;
     writeConstructorImplementation(className: string, signature: MethodSignature, op: (writer: this) => void, superCall?: Method, modifiers?: MethodModifier[]): void;
     writeMethodImplementation(method: Method, op: (writer: this) => void): void;
@@ -85,7 +85,7 @@ export declare class TSLanguageWriter extends LanguageWriter {
     get supportedFieldModifiers(): FieldModifier[];
     enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
     ordinalFromEnum(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
-    makeEnumCast(enumName: string, unsafe: boolean, convertor: ArgConvertor): string;
+    makeEnumCast(enumEntry: idl.IDLEnum, param: string): string;
     castToBoolean(value: string): string;
     makeCallIsObject(value: string): LanguageExpression;
     escapeKeyword(keyword: string): string;

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

@@ -13,11 +13,12 @@
  * limitations under the License.
  */
 import * as idl from '../../idl';
+import { isOptionalType } from '../../idl';
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { AssignStatement, BlockStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
-import { throwException } from "../../util";
+import { rightmostIndexOf, throwException } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
@@ -155,9 +156,10 @@ export class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeInterface(name, op, superInterfaces, isDeclared) {
+    writeInterface(name, op, superInterfaces, generics, isDeclared) {
+        const genericsClause = (generics === null || generics === void 0 ? void 0 : generics.length) ? `<${generics.join(", ")}>` : '';
         let extendsClause = superInterfaces ? ` extends ${superInterfaces.join(",")}` : '';
-        this.printer.print(`export ${isDeclared ? "declare " : ""}interface ${name}${extendsClause} {`);
+        this.printer.print(`export ${isDeclared ? "declare " : ""}interface ${name}${genericsClause}${extendsClause} {`);
         this.pushIndent();
         op(this);
         this.popIndent();
@@ -174,7 +176,11 @@ export class TSLanguageWriter extends LanguageWriter {
         this.printer.print('}');
     }
     generateFunctionDeclaration(name, signature) {
-        const args = signature.args.map((it, index) => `${signature.argName(index)}${idl.isOptionalType(it) ? '?' : ''}: ${this.getNodeName(it)}`);
+        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}`;
     }
@@ -202,7 +208,9 @@ export class TSLanguageWriter extends LanguageWriter {
             prefix += " ";
         this.printer.print(`${prefix}${name}${optional ? "?" : ""}: ${this.getNodeName(type)}${init}`);
     }
-    writeNativeMethodDeclaration(name, signature, isNative) {
+    writeNativeMethodDeclaration(method) {
+        let name = method.name;
+        let signature = method.signature;
         this.writeMethodImplementation(new Method(name, signature, [MethodModifier.STATIC]), writer => {
             const selfCallExpression = writer.makeFunctionCall(`this.${name}`, signature.args.map((_, i) => writer.makeString(this.escapeKeyword(signature.argName(i)))));
             writer.writeStatement(new IfStatement(new NaryOpExpression("==", [writer.makeFunctionCall("this._LoadOnce", []), writer.makeString("true")]), new BlockStatement([
@@ -272,7 +280,7 @@ export class TSLanguageWriter extends LanguageWriter {
         canBeOptional.reverse();
         const isOptional = signature.args.map((it, i) => idl.isOptionalType(it) && canBeOptional[i] && !isSetter);
         const normalizedArgs = signature.args.map((it, i) => idl.isOptionalType(it) && isOptional[i] ? idl.maybeUnwrapOptionalType(it) : it);
-        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${isOptional[index] ? "?" : ""}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""} ${needBracket ? "{" : ""}`);
+        this.printer.print(`${prefix}${name}${typeParams}(${normalizedArgs.map((it, index) => `${this.escapeKeyword(signature.argName(index))}${isOptional[index] ? "?" : ""}: ${this.getNodeName(it)}${signature.argDefault(index) ? ' = ' + signature.argDefault(index) : ""}`).join(", ")})${needReturn ? ": " + this.getNodeName(signature.returnType) : ""}${needBracket ? " {" : ""}`);
     }
     makeNull() {
         return new StringExpression("undefined");
@@ -364,7 +372,7 @@ export class TSLanguageWriter extends LanguageWriter {
         return this.makeAssign(receiver, undefined, this.makeString(`[${fields.map(it => `${it}!`).join(",")}]`), false);
     }
     get supportedModifiers() {
-        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.STATIC];
+        return [MethodModifier.PUBLIC, MethodModifier.PRIVATE, MethodModifier.PROTECTED, MethodModifier.STATIC];
     }
     get supportedFieldModifiers() {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];
@@ -380,11 +388,12 @@ export class TSLanguageWriter extends LanguageWriter {
         }
         return value;
     }
-    makeEnumCast(enumName, unsafe, convertor) {
-        if (unsafe) {
-            return this.makeUnsafeCast(convertor, enumName);
-        }
-        return enumName;
+    makeEnumCast(enumEntry, param) {
+        // Take the ordinal value if Enum is a string, and valueOf when it is an integer
+        // Enum.valueOf() - compatible with ArkTS/TS
+        return idl.isStringEnum(enumEntry)
+            ? this.ordinalFromEnum(this.makeString(param), idl.createReferenceType(enumEntry)).asString()
+            : `${param}.valueOf()`;
     }
     castToBoolean(value) { return `+${value}`; }
     makeCallIsObject(value) {