@idlizer/core 2.0.43 → 2.1.2

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

@@ -12,15 +12,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createReferenceType, forceAsNamedNode, IDLU32Type, IDLUint8ArrayType, IDLVoidType } from '../../idl';
+import { createReferenceType, forceAsNamedNode, IDLU32Type, IDLVoidType } from '../../idl';
 import { Language } from '../../Language';
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
 import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, NamedMethodSignature, StringExpression } from "../LanguageWriter";
 import { CDefinedExpression, CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import { RuntimeType } from "../common";
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { throwException } from "../../util";
 import { cppKeywords } from "../../languageSpecificKeywords";
+import * as idl from "../../idl";
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -217,7 +217,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.print(`}`);
     }
-    writeProperty(propName, propType, mutable = true) {
+    writeProperty(propName, propType, modifiers, getter, setter) {
         throw new Error("writeProperty for c++ is not implemented yet.");
     }
     writeTypeDeclaration(decl) {
@@ -376,7 +376,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     ordinalFromEnum(value, _) {
         return value;
     }
-    makeUnsafeCast(convertor, param) {
+    makeUnsafeCast(param) {
         return param;
     }
     makeUnsafeCast_(value, type, typeOptions) {
@@ -396,11 +396,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return `(${typeName}) (${value.asString()})`;
     }
-    makeEnumCast(value, _unsafe, convertor) {
-        if (convertor !== undefined) {
-            return `static_cast<${this.typeConvertor.convert(convertor.nativeType())}>(${value})`;
-        }
-        throwException("Need pass EnumConvertor");
+    makeEnumCast(enumEntry, value) {
+        return `static_cast<${this.typeConvertor.convert(idl.createReferenceType(enumEntry))}>(${value})`;
     }
     escapeKeyword(name) {
         return cppKeywords.has(name) ? name + "_" : name;
@@ -463,7 +460,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     }
     makeSerializerConstructorSignatures() {
         const fromBufferCtor = new NamedMethodSignature(IDLVoidType, [
-            IDLUint8ArrayType,
+            idl.IDLSerializerBuffer,
             IDLU32Type,
             createReferenceType("CallbackResourceHolder")
         ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], [undefined, undefined, undefined, PrintHint.AsPointer]);

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

@@ -42,7 +42,6 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     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;
@@ -55,12 +54,8 @@ 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;
-    isDirectType(type: IDLType): boolean;
     isQuickType(type: IDLType): boolean;
-    tryWriteQuick(method: Method): void;
     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 { 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                         //
 ////////////////////////////////////////////////////////////////
@@ -177,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);
     }
@@ -226,48 +218,15 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         // ArkTS does not support - 'this.?'
         super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
     }
-    isDirectType(type) {
-        let converted = this.getNodeName(type);
-        return type == idl.IDLI32Type || type == idl.IDLPointerType || type == idl.IDLBooleanType
-            || type == idl.IDLVoidType || converted == "KPointer" || converted == "KInt";
-    }
     isQuickType(type) {
         return idl.asPromise(type) == undefined;
     }
-    tryWriteQuick(method) {
-        var _a;
-        if ((_a = method.modifiers) === null || _a === void 0 ? void 0 : _a.includes(MethodModifier.THROWS))
-            return;
-        if (false && this.isDirectType(method.signature.returnType) && method.signature.args.every((type) => this.isDirectType(type))) {
-            this.print('@ani.unsafe.Direct');
-            return;
-        }
-        if (this.isQuickType(method.signature.returnType)) {
-            this.print('@ani.unsafe.Quick');
-            return;
-        }
-    }
     writeNativeMethodDeclaration(method) {
         if (method.signature.returnType === IDLThisType) {
             throw new Error('static method can not return this!');
         }
-        this.tryWriteQuick(method);
         this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
     }
-    writeProperty(propName, propType) {
-        throw new Error("writeProperty for ArkTS is not implemented yet.");
-    }
-    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`);
-        }
-        // ((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();
-    }
     makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
         if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
             return this.instanceOf(convertor, valueName);

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

@@ -40,7 +40,13 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     writeFieldDeclaration(name: string, type: idl.IDLType, modifiers: FieldModifier[] | undefined, optional: boolean, initExpr?: LanguageExpression): 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;
+    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     makeAssign(variableName: string, type: idl.IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
@@ -74,11 +80,11 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     makeClassInit(type: idl.IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     makeMapInit(type: idl.IDLType): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
-    enumFromOrdinal(value: LanguageExpression, _: idl.IDLType): LanguageExpression;
+    enumFromOrdinal(value: LanguageExpression, enumEntry: idl.IDLType): LanguageExpression;
     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

@@ -14,7 +14,7 @@
  */
 import { Language } from '../../Language';
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { AssignStatement, CheckOptionalStatement, FieldModifier, LambdaExpression, MethodModifier, } from "../LanguageWriter";
+import { AssignStatement, CheckOptionalStatement, FieldModifier, LambdaExpression, Method, MethodModifier, MethodSignature, NamedMethodSignature, } from "../LanguageWriter";
 import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import * as idl from '../../idl';
 import { RuntimeType } from "../common";
@@ -149,8 +149,29 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType) {
-        throw new Error("writeProperty for Java is not implemented yet.");
+    writeProperty(propName, propType, modifiers, getter, setter) {
+        let isStatic = modifiers.includes(FieldModifier.STATIC);
+        let isMutable = !modifiers.includes(FieldModifier.READONLY);
+        let containerName = propName.concat("_container");
+        if (getter) {
+            if (!getter.op) {
+                this.print(`private var ${this.getNodeName(propType)} ${containerName};`);
+            }
+            this.writeGetterImplementation(new Method(propName, new MethodSignature(propType, []), isStatic ? [MethodModifier.STATIC, MethodModifier.PUBLIC] : [MethodModifier.PUBLIC]), getter ? getter.op :
+                (writer) => {
+                    writer.print(`return ${containerName}`);
+                });
+            if (isMutable) {
+                const setSignature = new NamedMethodSignature(idl.IDLVoidType, [propType], [propName]);
+                this.writeSetterImplementation(new Method(propName, setSignature, isStatic ? [MethodModifier.STATIC, MethodModifier.PUBLIC] : [MethodModifier.PUBLIC]), setter ? setter.op :
+                    (writer) => {
+                        writer.print(`${containerName} = ${propName};`);
+                    });
+            }
+        }
+        else {
+            this.writeMethodDeclaration(propName, new MethodSignature(propType, []));
+        }
     }
     writeTypeDeclaration(decl) {
         throw new Error(`Type declarations do not exist in Java, use something else`);
@@ -255,11 +276,13 @@ export class JavaLanguageWriter extends CLikeLanguageWriter {
     makeTupleAccess(value, index) {
         return this.makeString(`${value}.value${index}`);
     }
-    enumFromOrdinal(value, _) {
-        throw new Error("Method not implemented.");
+    enumFromOrdinal(value, enumEntry) {
+        const enumName = idl.forceAsNamedNode(enumEntry).name;
+        const ordinal = value.asString();
+        return this.makeString(`${enumName}.values()[${ordinal}]`);
     }
     ordinalFromEnum(value, _) {
-        return this.makeString(`${value.asString()}.value`);
+        return this.makeString(`${value.asString()}.ordinal()`);
     }
     makeValueFromOption(value) {
         return this.makeString(`${value}`);
@@ -267,7 +290,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

@@ -53,7 +53,13 @@ export declare class TSLanguageWriter extends LanguageWriter {
     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;
-    writeProperty(propName: string, propType: idl.IDLType): void;
+    writeProperty(propName: string, propType: idl.IDLType, modifiers: FieldModifier[], getter?: {
+        method: Method;
+        op: () => void;
+    }, setter?: {
+        method: Method;
+        op: () => void;
+    }): void;
     writeTypeDeclaration(decl: idl.IDLTypedef): void;
     writeConstant(constName: string, constType: idl.IDLType, constVal?: string): void;
     private writeDeclaration;
@@ -85,7 +91,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,13 +13,14 @@
  * 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 { AssignStatement, BlockStatement, CheckOptionalStatement, ExpressionStatement, FieldModifier, IfStatement, LambdaExpression, LanguageWriter, Method, MethodModifier, MethodSignature, NamedMethodSignature, NaryOpExpression, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { RuntimeType } from "../common";
 import { rightmostIndexOf, throwException } from "../../util";
 import { TSKeywords } from '../../languageSpecificKeywords';
-import { isOptionalType } from "../../idl";
+import { isStringEnumType } from '../../peer-generation/isEnumType';
 ////////////////////////////////////////////////////////////////
 //                        EXPRESSIONS                         //
 ////////////////////////////////////////////////////////////////
@@ -223,7 +224,7 @@ export class TSLanguageWriter extends LanguageWriter {
         this.writeDeclaration(name, signature, true, false, modifiers);
     }
     writeConstructorImplementation(className, signature, op, superCall, modifiers) {
-        this.writeDeclaration(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') : ''} constructor`, signature, false, true);
+        this.writeDeclaration(`${modifiers ? modifiers.map((it) => MethodModifier[it].toLowerCase()).join(' ') + ' ' : ''}constructor`, signature, false, true);
         this.pushIndent();
         if (superCall) {
             this.print(`super(${superCall.signature.args.map((_, i) => superCall === null || superCall === void 0 ? void 0 : superCall.signature.argName(i)).join(", ")})`);
@@ -239,8 +240,29 @@ export class TSLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType) {
-        throw new Error("writeProperty for TS is not implemented yet.");
+    writeProperty(propName, propType, modifiers, getter, setter) {
+        let isStatic = modifiers.includes(FieldModifier.STATIC);
+        let isMutable = !modifiers.includes(FieldModifier.READONLY);
+        let containerName = propName.concat("_container");
+        if (getter) {
+            if (!getter.op) {
+                this.print(`private var ${this.getNodeName(propType)} ${containerName}`);
+            }
+            this.writeGetterImplementation(new Method(propName, new MethodSignature(propType, []), isStatic ? [MethodModifier.STATIC] : []), getter ? getter.op :
+                (writer) => {
+                    writer.print(`return ${containerName}`);
+                });
+            if (isMutable) {
+                const setSignature = new NamedMethodSignature(idl.IDLVoidType, [propType], [propName]);
+                this.writeSetterImplementation(new Method(propName, setSignature, isStatic ? [MethodModifier.STATIC] : []), setter ? setter.op :
+                    (writer) => {
+                        writer.print(`${containerName} = ${propName}`);
+                    });
+            }
+        }
+        else {
+            this.writeFieldDeclaration(propName, propType, modifiers, idl.isOptionalType(propType));
+        }
     }
     writeTypeDeclaration(decl) {
         var _a;
@@ -378,7 +400,11 @@ export class TSLanguageWriter extends LanguageWriter {
         return [FieldModifier.PUBLIC, FieldModifier.PRIVATE, FieldModifier.PROTECTED, FieldModifier.READONLY, FieldModifier.STATIC];
     }
     enumFromOrdinal(value, enumEntry) {
-        return this.makeString(`Object.values(${idl.forceAsNamedNode(enumEntry).name})[${value.asString()}]`);
+        const enumName = idl.forceAsNamedNode(enumEntry).name;
+        const ordinal = value.asString();
+        return isStringEnumType(enumEntry, this.resolver)
+            ? this.makeString(`Object.values(${enumName})[${ordinal}]`)
+            : this.makeString(`${ordinal}`);
     }
     ordinalFromEnum(value, enumEntry) {
         const enumName = idl.forceAsNamedNode(enumEntry).name;
@@ -388,11 +414,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) {

package/build/lib/src/LibraryInterface.d.ts

@@ -9,7 +9,6 @@ export interface LibraryFileInterface {
 export interface LibraryInterface extends ReferenceResolver {
     language: Language;
     get files(): LibraryFileInterface[];
-    get libraryPackages(): string[] | undefined;
     typeConvertor(param: string, type: idl.IDLType, isOptionalParam?: boolean): ArgConvertor;
     declarationConvertor(param: string, type: idl.IDLReferenceType, declaration: idl.IDLEntry | undefined): ArgConvertor;
     getInteropName(node: idl.IDLNode): string;