@idlizer/core 2.1.9-arktscgen-6 → 2.1.9-arktscgen-9

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

@@ -16,7 +16,7 @@ import * as idl from "../../idl";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { CJKeywords } from "../../languageSpecificKeywords";
 import { RuntimeType } from "../common";
-import { AssignStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
+import { AssignStatement, BlockStatement, ExpressionStatement, FieldModifier, LambdaExpression, LanguageWriter, MethodModifier, MethodSignature, ReturnStatement, StringExpression } from "../LanguageWriter";
 import { Language } from "../../Language";
 import { indentedBy, isDefined } from "../../util";
 ////////////////////////////////////////////////////////////////
@@ -145,16 +145,16 @@ class CJLoopStatement {
     }
 }
 class CJMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for ((${this.key}, ${this.value}) in ${this.map}) {`);
         writer.pushIndent();
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -227,20 +227,6 @@ class CJThrowErrorStatement {
         writer.print(`throw Exception("${this.message}")`);
     }
 }
-class CJCheckOptionalStatement {
-    constructor(undefinedValue, optionalExpression, doStatement) {
-        this.undefinedValue = undefinedValue;
-        this.optionalExpression = optionalExpression;
-        this.doStatement = doStatement;
-    }
-    write(writer) {
-        writer.print(`if (let Some(${this.optionalExpression.asString()}) <- ${this.optionalExpression.asString()}) {`);
-        writer.pushIndent();
-        this.doStatement.write(writer);
-        writer.popIndent();
-        writer.print('}');
-    }
-}
 class CJArrayResizeStatement {
     constructor(array, arrayType, length, deserializer) {
         this.array = array;
@@ -377,7 +363,7 @@ export class CJLanguageWriter extends LanguageWriter {
         this.popIndent();
         this.printer.print(`}`);
     }
-    writeProperty(propName, propType, modifiers, getter, setter) {
+    writeProperty(propName, propType, modifiers, getter, setter, initExpr) {
         let containerName = propName.concat("_container");
         let truePropName = this.escapeKeyword(propName);
         if (getter) {
@@ -387,7 +373,8 @@ export class CJLanguageWriter extends LanguageWriter {
         }
         let isStatic = modifiers.includes(FieldModifier.STATIC);
         let isMutable = !modifiers.includes(FieldModifier.READONLY);
-        this.print(`public ${isMutable ? "mut " : ""}${isStatic ? "static " : "open "}prop ${truePropName}: ${this.getNodeName(propType)}`);
+        let initializer = initExpr ? ` = ${initExpr.asString()}` : "";
+        this.print(`public ${isMutable ? "mut " : ""}${isStatic ? "static " : "open "}prop ${truePropName}: ${this.getNodeName(propType)}${initializer}`);
         if (getter) {
             this.print('{');
             this.pushIndent();
@@ -490,17 +477,14 @@ export class CJLanguageWriter extends LanguageWriter {
     makeReturn(expr) {
         return new ReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        return new CJCheckOptionalStatement("undefined", optional, doStatement);
-    }
     makeStatement(expr) {
         return new ExpressionStatement(expr);
     }
     makeLoop(counter, limit, statement) {
         return new CJLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new CJMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new CJMapForEachStatement(map, key, value, body);
     }
     makeDefinedCheck(value) {
         return new CJCheckDefinedExpression(this.escapeKeyword(value));

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

@@ -8,11 +8,6 @@ export declare class CLikeReturnStatement extends ReturnStatement {
     constructor(expression: LanguageExpression);
     write(writer: LanguageWriter): void;
 }
-export declare class CDefinedExpression implements LanguageExpression {
-    private value;
-    constructor(value: string);
-    asString(): string;
-}
 export declare class CLikeLoopStatement implements LanguageStatement {
     private counter;
     private limit;

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

@@ -12,7 +12,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
 import { ExpressionStatement, LanguageWriter, Method, ReturnStatement } from "../LanguageWriter";
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
@@ -26,14 +25,6 @@ export class CLikeReturnStatement extends ReturnStatement {
         writer.print(this.expression ? `return ${this.expression.asString()};` : "return;");
     }
 }
-export class CDefinedExpression {
-    constructor(value) {
-        this.value = value;
-    }
-    asString() {
-        return `${this.value} != ${PrimitiveTypeList.UndefinedTag}`;
-    }
-}
 export class CLikeLoopStatement {
     constructor(counter, limit, statement) {
         this.counter = counter;

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

@@ -1,7 +1,7 @@
 import { IDLContainerType, IDLEnum, IDLNode, IDLType, IDLTypedef } from '../../idl';
 import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
-import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, MakeRefOptions, Method, PrintHint, MethodModifier, MethodSignature, NamedMethodSignature, ObjectArgs, DelegationCall, MethodStaticCallExpression } from "../LanguageWriter";
+import { AssignStatement, FieldModifier, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, MakeRefOptions, Method, PrintHint, MethodModifier, MethodSignature, ObjectArgs, DelegationCall, MethodStaticCallExpression } from "../LanguageWriter";
 import { CLikeLanguageWriter } from "./CLikeLanguageWriter";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
@@ -85,16 +85,14 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression | undefined, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     makeStatement(expr: LanguageExpression): LanguageStatement;
     makeArrayAccess(value: string, indexVar: string): LanguageExpression;
     makeTupleAccess(value: string, index: number): LanguageExpression;
     makeUnionSelector(value: string, valueType: string): LanguageStatement;
-    makeUnionVariantCondition(_convertor: ArgConvertor, _valueName: string, valueType: string, type: string, convertorIndex: number): LanguageExpression;
     makeUnionVariantCast(value: string, type: string, convertor: ArgConvertor, index: number): LanguageExpression;
     makeStaticMethodCall(receiver: string, method: string, params: LanguageExpression[], nullable?: boolean): LanguageExpression;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     makeArrayInit(type: IDLContainerType): LanguageExpression;
     makeClassInit(type: IDLType, paramenters: LanguageExpression[]): LanguageExpression;
     makeMapInit(type: IDLType): LanguageExpression;
@@ -103,7 +101,7 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     makeCast(expr: LanguageExpression, node: IDLNode, options?: MakeCastOptions): LanguageExpression;
     makePointerPropertyAccessExpression(expression: string, name: string): CppPointerPropertyAccessExpression;
     writePrintLog(message: string): void;
-    makeDefinedCheck(value: string): LanguageExpression;
+    makeDefinedCheck(value: string, isTag?: boolean): LanguageExpression;
     makeSetUnionSelector(value: string, index: string): LanguageStatement;
     makeSetOptionTag(value: string, tag: LanguageExpression): LanguageStatement;
     getObjectAccessor(convertor: BaseArgConvertor, value: string, args?: ObjectArgs): string;
@@ -129,6 +127,6 @@ export declare class CppLanguageWriter extends CLikeLanguageWriter {
     stringifyMethodReturnType(type: IDLType, hint?: PrintHint): string;
     stringifyMethodArgType(type: IDLType, hint?: PrintHint): string;
     stringifyTypeWithReceiver(type: IDLType, receiver?: string): string;
-    makeSerializerConstructorSignatures(): NamedMethodSignature[] | undefined;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
 }
 //# sourceMappingURL=CppLanguageWriter.d.ts.map

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

@@ -12,11 +12,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { createReferenceType, forceAsNamedNode, IDLU32Type, IDLVoidType } from '../../idl';
+import { createReferenceType, forceAsNamedNode } from '../../idl';
 import { Language } from '../../Language';
 import { PrimitiveTypeList } from "../../peer-generation/PrimitiveType";
-import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, NamedMethodSignature, StringExpression, MethodStaticCallExpression } from "../LanguageWriter";
-import { CDefinedExpression, CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
+import { AssignStatement, BlockStatement, FieldModifier, PrintHint, MethodModifier, StringExpression, MethodStaticCallExpression } from "../LanguageWriter";
+import { CLikeExpressionStatement, CLikeLanguageWriter, CLikeLoopStatement, CLikeReturnStatement } from "./CLikeLanguageWriter";
 import { RuntimeType } from "../common";
 import { IndentedPrinter } from "../../IndentedPrinter";
 import { cppKeywords } from "../../languageSpecificKeywords";
@@ -123,18 +123,18 @@ class CppMapResizeStatement {
     }
 }
 class CppMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (int32_t i = 0; i < ${this.map}.size; i++) {`);
         writer.pushIndent();
         writer.print(`auto ${this.key} = ${this.map}.keys[i];`);
         writer.print(`auto ${this.value} = ${this.map}.values[i];`);
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -179,7 +179,7 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     }
     fork(options) {
         var _a;
-        return new CppLanguageWriter(new IndentedPrinter(), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
+        return new CppLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.primitivesTypes);
     }
     writeDeclaration(name, signature, modifiers, postfix) {
         const realName = this.classMode === 'normal' ? name : `${this.currentClass.at(0)}::${name}`;
@@ -294,14 +294,11 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         return new CppAssignStatement(variableName, type, expr, isDeclared, isConst, options);
     }
     makeLambda(signature, body) {
-        throw new Error(`TBD`);
+        throw new Error(`Improve`);
     }
     makeReturn(expr) {
         return new CLikeReturnStatement(expr);
     }
-    makeCheckOptional(optional, doStatement) {
-        throw new Error(`TBD`);
-    }
     makeStatement(expr) {
         return new CLikeExpressionStatement(expr);
     }
@@ -314,9 +311,6 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     makeUnionSelector(value, valueType) {
         return this.makeAssign(valueType, undefined, this.makeString(`${value}.selector`), false);
     }
-    makeUnionVariantCondition(_convertor, _valueName, valueType, type, convertorIndex) {
-        return this.makeString(`${valueType} == ${convertorIndex}`);
-    }
     makeUnionVariantCast(value, type, convertor, index) {
         return this.makeString(`${value}.value${index}`);
     }
@@ -326,8 +320,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     makeLoop(counter, limit, statement) {
         return new CLikeLoopStatement(counter, limit, statement);
     }
-    makeMapForEach(map, key, value, op) {
-        return new CppMapForEachStatement(map, key, value, op);
+    makeMapForEach(map, key, value, body) {
+        return new CppMapForEachStatement(map, key, value, body);
     }
     makeArrayInit(type) {
         return this.makeString(`{}`);
@@ -353,8 +347,9 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
     writePrintLog(message) {
         this.print(`printf("${message}\\n");`);
     }
-    makeDefinedCheck(value) {
-        return new CDefinedExpression(value);
+    makeDefinedCheck(value, isTag) {
+        return this.makeString(isTag ? `${value} != ${PrimitiveTypeList.UndefinedTag}`
+            : `runtimeType(${value}) != ${PrimitiveTypeList.UndefinedRuntime}`);
     }
     makeSetUnionSelector(value, index) {
         return this.makeAssign(`${value}.selector`, undefined, this.makeString(index), false);
@@ -488,16 +483,8 @@ export class CppLanguageWriter extends CLikeLanguageWriter {
         }
         return this.getNodeName(type);
     }
-    makeSerializerConstructorSignatures() {
-        const fromBufferCtor = new NamedMethodSignature(IDLVoidType, [
-            idl.IDLSerializerBuffer,
-            IDLU32Type,
-            createReferenceType("CallbackResourceHolder")
-        ], ["data", "dataLength", "resourceHolder"], [undefined, `0`, `nullptr`], undefined, [undefined, undefined, undefined, PrintHint.AsPointer]);
-        const ownedDataCtor = new NamedMethodSignature(IDLVoidType, [
-            createReferenceType("CallbackResourceHolder")
-        ], ["resourceHolder"], [`nullptr`], undefined, [undefined, PrintHint.AsPointer]);
-        return [ownedDataCtor, fromBufferCtor];
+    discriminate(value, index, type, runtimeTypes) {
+        return `${value}.selector == ${index}`;
     }
 }
 //# sourceMappingURL=CppLanguageWriter.js.map

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

@@ -1,18 +1,26 @@
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeCastOptions, Method, MethodModifier, MethodSignature, ObjectArgs } from "../LanguageWriter";
+import { LambdaExpression, LanguageExpression, LanguageStatement, LanguageWriter, MakeAssignOptions, MakeCastOptions, Method, MethodModifier, MethodSignature } from "../LanguageWriter";
 import { TSLanguageWriter } from "./TsLanguageWriter";
 import { IDLEnum, IDLType } from '../../idl';
 import { ArgConvertor } from "../ArgConvertors";
 import * as idl from '../../idl';
 import { IdlNameConvertor } from "../nameConvertor";
+import { RuntimeType } from "../common";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
+export declare class ETSStringExpression implements LanguageExpression {
+    value: string;
+    constructor(value: string);
+    private changeQuotes;
+    asString(): string;
+}
 export declare class EtsAssignStatement implements LanguageStatement {
     variableName: string;
     type: IDLType | undefined;
     expression: LanguageExpression;
     isDeclared: boolean;
     protected isConst: boolean;
-    constructor(variableName: string, type: IDLType | undefined, expression: LanguageExpression, isDeclared?: boolean, isConst?: boolean);
+    protected options?: MakeAssignOptions | undefined;
+    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 {
@@ -40,9 +48,10 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
     fork(options?: {
         resolver?: ReferenceResolver;
     }): LanguageWriter;
-    makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean): LanguageStatement;
+    makeAssign(variableName: string, type: IDLType | undefined, expr: LanguageExpression, isDeclared?: boolean, isConst?: boolean, options?: MakeAssignOptions): LanguageStatement;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeString(value: string): LanguageExpression;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
     get supportedModifiers(): MethodModifier[];
     runtimeType(param: ArgConvertor, valueType: string, value: string): void;
@@ -53,23 +62,18 @@ export declare class ETSLanguageWriter extends TSLanguageWriter {
         targetType: (writer: LanguageWriter) => string;
     }, value: string, accessors: string[], duplicates: Set<string>): LanguageExpression;
     makeValueFromOption(value: string, destinationConvertor: ArgConvertor): LanguageExpression;
-    makeIsTypeCall(value: string, decl: idl.IDLInterface): LanguageExpression;
     makeEnumEntity(enumEntity: IDLEnum, options: {
         isExport: boolean;
         isDeclare?: 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;
-    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;
     makeEquals(args: LanguageExpression[]): LanguageExpression;
-    makeDiscriminatorConvertor(convertor: ArgConvertor, value: string, index: number): LanguageExpression;
+    discriminate(value: string, index: number, type: idl.IDLType, runtimeTypes: RuntimeType[]): string;
     castToInt(value: string, bitness: 8 | 32): string;
     castToBoolean(value: string): string;
-    instanceOf(convertor: ArgConvertor, value: string, duplicateMembers?: Set<string>): LanguageExpression;
     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;

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

@@ -13,27 +13,45 @@
  * limitations under the License.
  */
 import { IndentedPrinter } from "../../IndentedPrinter";
-import { LambdaExpression, MethodModifier } from "../LanguageWriter";
+import { BlockStatement, LambdaExpression, MethodModifier } from "../LanguageWriter";
 import { TSCastExpression, TSLanguageWriter } from "./TsLanguageWriter";
 import { getExtAttribute, IDLThisType } from '../../idl';
-import { AggregateConvertor, ArrayConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor, OptionConvertor, UnionConvertor, BufferConvertor } from "../ArgConvertors";
+import { AggregateConvertor, CustomTypeConvertor, InterfaceConvertor, MaterializedClassConvertor } 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";
+////////////////////////////////////////////////////////////////
+//                        EXPRESSIONS                         //
+////////////////////////////////////////////////////////////////
+export class ETSStringExpression {
+    constructor(value) {
+        this.value = value;
+    }
+    changeQuotes(value) {
+        return `'${value.substring(1, value.length - 1)}'`;
+    }
+    asString() {
+        if (this.value.startsWith('"') && this.value.endsWith('"')) {
+            return this.changeQuotes(this.value);
+        }
+        return this.value;
+    }
+}
 ////////////////////////////////////////////////////////////////
 //                         STATEMENTS                         //
 ////////////////////////////////////////////////////////////////
 export class EtsAssignStatement {
-    constructor(variableName, type, expression, isDeclared = true, isConst = true) {
+    constructor(variableName, type, expression, isDeclared = true, isConst = true, options) {
         this.variableName = variableName;
         this.type = type;
         this.expression = expression;
         this.isDeclared = isDeclared;
         this.isConst = isConst;
+        this.options = options;
     }
     write(writer) {
+        var _a;
         if (this.isDeclared) {
             const typeClause = this.type !== undefined ? `: ${writer.getNodeName(this.type)}` : '';
             const maybeAssign = this.expression !== undefined ? " = " : "";
@@ -41,23 +59,25 @@ export class EtsAssignStatement {
             writer.print(`${this.isConst ? "const" : "let"} ${this.variableName} ${typeClause}${maybeAssign}${initValue.asString()}`);
         }
         else {
-            writer.print(`${this.variableName} = ${this.expression.asString()}`);
+            const receiver = (_a = this.options) === null || _a === void 0 ? void 0 : _a.receiver;
+            const withReceiver = receiver ? `${receiver}.` : "";
+            writer.print(`${withReceiver}${this.variableName} = ${this.expression.asString()}`);
         }
     }
 }
 class ArkTSMapForEachStatement {
-    constructor(map, key, value, op) {
+    constructor(map, key, value, body) {
         this.map = map;
         this.key = key;
         this.value = value;
-        this.op = op;
+        this.body = body;
     }
     write(writer) {
         writer.print(`for (const pair of ${this.map}) {`);
         writer.pushIndent();
         writer.print(`const ${this.key} = pair[0]`);
         writer.print(`const ${this.value} = pair[1]`);
-        this.op();
+        writer.writeStatement(new BlockStatement(this.body, false));
         writer.popIndent();
         writer.print(`}`);
     }
@@ -123,17 +143,17 @@ export class ETSLambdaExpression extends LambdaExpression {
             isRetTypeCallback = resolved !== undefined && idl.isCallback(resolved);
         }
         return `(${params.join(", ")})${isRetTypeCallback
-            ? "" : `:${this.convertor.convert(this.signature.returnType)}`} => { ${this.bodyAsString()} }`;
+            ? "" : `:${this.convertor.convert(this.signature.returnType)}`} =>${this.bodyAsString(true)}`;
     }
 }
 ////////////////////////////////////////////////////////////////
 //                           UTILS                            //
 ////////////////////////////////////////////////////////////////
 export function generateTypeCheckerName(typeName) {
-    typeName = typeName
+    return "is" + typeName
         .replaceAll('[]', 'BracketsArray')
-        .split('.').join('_');
-    return `is${typeName.replaceAll('[]', 'Brackets')}`;
+        .replaceAll(/<.*$/g, '') // delete type arguments
+        .replaceAll('.', '_');
 }
 export function generateEnumToNumericName(entry) {
     const typeName = idl.getQualifiedName(entry, "namespace.name").split('.').join('_');
@@ -157,16 +177,19 @@ export class ETSLanguageWriter extends TSLanguageWriter {
     }
     fork(options) {
         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);
+        return new ETSLanguageWriter(new IndentedPrinter([], this.indentDepth()), (_a = options === null || options === void 0 ? void 0 : options.resolver) !== null && _a !== void 0 ? _a : this.resolver, this.typeConvertor, this.arrayConvertor);
     }
-    makeAssign(variableName, type, expr, isDeclared = true, isConst = true) {
-        return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst);
+    makeAssign(variableName, type, expr, isDeclared = true, isConst = true, options) {
+        return new EtsAssignStatement(variableName, type, expr, isDeclared, isConst, options);
     }
     makeLambda(signature, body) {
         return new ETSLambdaExpression(this, this.typeConvertor, signature, this.resolver, body);
     }
-    makeMapForEach(map, key, value, op) {
-        return new ArkTSMapForEachStatement(map, key, value, op);
+    makeString(value) {
+        return new ETSStringExpression(value);
+    }
+    makeMapForEach(map, key, value, body) {
+        return new ArkTSMapForEachStatement(map, key, value, body);
     }
     makeMapSize(map) {
         return this.makeString(`${super.makeMapSize(map).asString()}`); // TODO: cast really needed?
@@ -202,7 +225,7 @@ export class ETSLanguageWriter extends TSLanguageWriter {
             || convertor instanceof InterfaceConvertor
             || convertor instanceof MaterializedClassConvertor
             || convertor instanceof CustomTypeConvertor) {
-            return this.instanceOf(convertor, value, duplicates);
+            return this.instanceOf(value, convertor.idlType);
         }
         return this.makeString(`${value} instanceof ${convertor.targetType(this)}`);
     }
@@ -212,18 +235,12 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         return super.makeValueFromOption(value, destinationConvertor);
     }
-    makeIsTypeCall(value, decl) {
-        return makeInterfaceTypeCheckerCall(value, decl.name, decl.properties.map(it => it.name), new Set(), this);
-    }
     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),
         });
     }
-    getObjectAccessor(convertor, value, args) {
-        return super.getObjectAccessor(convertor, value, args);
-    }
     writeMethodCall(receiver, method, params, nullable = false) {
         // ArkTS does not support - 'this.?'
         super.writeMethodCall(receiver, method, params, nullable && receiver !== "this");
@@ -237,46 +254,27 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         }
         this.writeMethodDeclaration(method.name, method.signature, [MethodModifier.STATIC, MethodModifier.NATIVE]);
     }
-    makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex, runtimeTypeIndex) {
-        if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
-            return this.instanceOf(convertor, valueName);
-        }
-        // TODO: in ArkTS SerializerBase.runtimeType returns RuntimeType.OBJECT for enum type and not RuntimeType.NUMBER as in TS
-        if (convertor instanceof UnionConvertor || convertor instanceof OptionConvertor) {
-            // Unwrapping of type
-            const idlType = convertor instanceof UnionConvertor
-                ? convertor.nativeType().types[runtimeTypeIndex]
-                : idl.maybeUnwrapOptionalType(convertor.nativeType());
-            if (idlType !== undefined && idl.isReferenceType(idlType)) {
-                const resolved = this.resolver.resolveTypeReference(idlType);
-                type = resolved != undefined && idl.isEnum(resolved) ? RuntimeType[RuntimeType.OBJECT] : type;
-            }
-        }
-        return super.makeUnionVariantCondition(convertor, valueName, valueType, type, convertorIndex);
-    }
     makeCastCustomObject(customName, isGenericType) {
         if (isGenericType) {
             return this.makeCast(this.makeString(customName), idl.IDLObjectType);
         }
         return super.makeCastCustomObject(customName, isGenericType);
     }
-    makeHasOwnProperty(value, valueTypeName, property, propertyTypeName) {
-        return this.makeNaryOp("&&", [
-            this.makeString(`${value} instanceof ${valueTypeName}`),
-            this.makeString(`isInstanceOf("${propertyTypeName}", ${value}.${property})`)
-        ]);
-    }
     makeEquals(args) {
         // TODO: Error elimination: 'TypeError: Both operands have to be reference types'
         // the '==' operator must be used when one of the operands is a reference
         return super.makeNaryOp('==', args);
     }
-    makeDiscriminatorConvertor(convertor, value, index) {
-        return this.instanceOf(convertor, value);
-        // Or this ????????
-        // return this.discriminatorFromExpressions(value, RuntimeType.OBJECT, [
-        //     makeEnumTypeCheckerCall(value, this.getNodeName(convertor.idlType), this)
-        // ])
+    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)}`;
     }
     castToInt(value, bitness) {
         // This fix is used to avoid unnecessary writeInt8(value as int32) call, which is generated if value is already an int32
@@ -287,27 +285,6 @@ export class ETSLanguageWriter extends TSLanguageWriter {
         return `(${value}).toInt()`; // FIXME: is there int8 in ARKTS?
     }
     castToBoolean(value) { return `${value} ? 1 : 0`; }
-    instanceOf(convertor, value, duplicateMembers) {
-        if (convertor instanceof CustomTypeConvertor) {
-            return makeInterfaceTypeCheckerCall(value, this.getNodeName(convertor.idlType), [], duplicateMembers, this);
-        }
-        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);
-        }
-        if (convertor instanceof ArrayConvertor) {
-            return makeArrayTypeCheckCall(value, this.arrayConvertor.convert(convertor.idlType), this);
-        }
-        if (idl.isEnum(this.resolver.toDeclaration(convertor.nativeType()))) {
-            return makeEnumTypeCheckerCall(value, this.getNodeName(convertor.idlType), this);
-        }
-        return super.instanceOf(convertor, value, duplicateMembers);
-    }
     typeInstanceOf(type, value, members) {
         if (!members || members.length === 0) {
             throw new Error("At least one member needs to provided to pass it to TypeChecker!");

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

@@ -6,11 +6,6 @@ import { ArgConvertor, BaseArgConvertor } from "../ArgConvertors";
 import { IdlNameConvertor } from "../nameConvertor";
 import { RuntimeType } from "../common";
 import { ReferenceResolver } from "../../peer-generation/ReferenceResolver";
-export declare class JavaCheckDefinedExpression implements LanguageExpression {
-    private value;
-    constructor(value: string);
-    asString(): string;
-}
 export declare class JavaCastExpression implements LanguageExpression {
     value: LanguageExpression;
     type: string;
@@ -46,16 +41,15 @@ export declare class JavaLanguageWriter extends CLikeLanguageWriter {
     }, setter?: {
         method: Method;
         op: () => void;
-    }): void;
+    }, initExpr?: LanguageExpression): 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;
     makeLambda(signature: MethodSignature, body?: LanguageStatement[]): LanguageExpression;
     makeReturn(expr: LanguageExpression): LanguageStatement;
-    makeCheckOptional(optional: LanguageExpression, doStatement: LanguageStatement): LanguageStatement;
     makeDefinedCheck(value: string): LanguageExpression;
     makeLoop(counter: string, limit: string, statement?: LanguageStatement): LanguageStatement;
-    makeMapForEach(map: string, key: string, value: string, op: () => void): LanguageStatement;
+    makeMapForEach(map: string, key: string, value: string, body: LanguageStatement[]): LanguageStatement;
     makeMapSize(map: string): LanguageExpression;
     makeCast(value: LanguageExpression, node: idl.IDLNode, options?: MakeCastOptions): LanguageExpression;
     makeStatement(expr: LanguageExpression): LanguageStatement;